src/ddns/providers.py

   1 #!/usr/bin/python3
   2 ###############################################################################
   3 #                                                                             #
   4 # ddns - A dynamic DNS client for IPFire                                      #
   5 # Copyright (C) 2012-2017 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 ###############################################################################
  21
  22 import datetime
  23 import logging
  24 import os
  25 import subprocess
  26 import urllib.request
  27 import urllib.error
  28 import urllib.parse
  29 import xml.dom.minidom
  30
  31 from .i18n import _
  32
  33 # Import all possible exception types.
  34 from .errors import *
  35
  36 logger = logging.getLogger("ddns.providers")
  37 logger.propagate = 1
  38
  39 _providers = {}
  40
  41 def get():
  42         """
  43                 Returns a dict with all automatically registered providers.
  44         """
  45         return _providers.copy()
  46
  47 class DDNSProvider(object):
  48         # A short string that uniquely identifies
  49         # this provider.
  50         handle = None
  51
  52         # The full name of the provider.
  53         name = None
  54
  55         # A weburl to the homepage of the provider.
  56         # (Where to register a new account?)
  57         website = None
  58
  59         # A list of supported protocols.
  60         protocols = ("ipv6", "ipv4")
  61
  62         DEFAULT_SETTINGS = {}
  63
  64         # holdoff time - Number of days no update is performed unless
  65         # the IP address has changed.
  66         holdoff_days = 30
  67
  68         # holdoff time for update failures - Number of days no update
  69         # is tried after the last one has failed.
  70         holdoff_failure_days = 0.5
  71
  72         # True if the provider is able to remove records, too.
  73         # Required to remove AAAA records if IPv6 is absent again.
  74         can_remove_records = True
  75
  76         # True if the provider supports authentication via a random
  77         # generated token instead of username and password.
  78         supports_token_auth = True
  79
  80         @staticmethod
  81         def supported():
  82                 """
  83                         Should be overwritten to check if the system the code is running
  84                         on has all the required tools to support this provider.
  85                 """
  86                 return True
  87
  88         def __init__(self, core, **settings):
  89                 self.core = core
  90
  91                 # Copy a set of default settings and
  92                 # update them by those from the configuration file.
  93                 self.settings = self.DEFAULT_SETTINGS.copy()
  94                 self.settings.update(settings)
  95
  96         def __init_subclass__(cls, **kwargs):
  97                 super().__init_subclass__(**kwargs)
  98
  99                 if not all((cls.handle, cls.name, cls.website)):
 100                         raise DDNSError(_("Provider is not properly configured"))
 101
 102                 assert cls.handle not in _providers, \
 103                         "Provider '%s' has already been registered" % cls.handle
 104
 105                 # Register class
 106                 _providers[cls.handle] = cls
 107
 108         def __repr__(self):
 109                 return "<DDNS Provider %s (%s)>" % (self.name, self.handle)
 110
 111         def __cmp__(self, other):
 112                 return (lambda a, b: (a > b)-(a < b))(self.hostname, other.hostname)
 113
 114         @property
 115         def db(self):
 116                 return self.core.db
 117
 118         def get(self, key, default=None):
 119                 """
 120                         Get a setting from the settings dictionary.
 121                 """
 122                 return self.settings.get(key, default)
 123
 124         @property
 125         def hostname(self):
 126                 """
 127                         Fast access to the hostname.
 128                 """
 129                 return self.get("hostname")
 130
 131         @property
 132         def username(self):
 133                 """
 134                         Fast access to the username.
 135                 """
 136                 return self.get("username")
 137
 138         @property
 139         def password(self):
 140                 """
 141                         Fast access to the password.
 142                 """
 143                 return self.get("password")
 144
 145         @property
 146         def token(self):
 147                 """
 148                         Fast access to the token.
 149                 """
 150                 return self.get("token")
 151
 152         def __call__(self, force=False):
 153                 if force:
 154                         logger.debug(_("Updating %s forced") % self.hostname)
 155
 156                 # Do nothing if the last update has failed or no update is required
 157                 elif self.has_failure or not self.requires_update:
 158                         return
 159
 160                 # Execute the update.
 161                 try:
 162                         self.update()
 163
 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
 169                 # shortly.
 170                 except (DDNSNetworkError, DDNSInternalServerError):
 171                         raise
 172
 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)
 177                         raise
 178
 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)
 182
 183         def update(self):
 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)
 189
 190         def update_protocol(self, proto):
 191                 raise NotImplementedError
 192
 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")
 196
 197                 raise NotImplementedError
 198
 199         @property
 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) is performed because of an IP address change") %
 204                         {"hostname": self.hostname, "provider": self.name})
 205
 206                         return True
 207
 208                 # If the holdoff time has expired, an update is required, too
 209                 if self.holdoff_time_expired():
 210                         logger.debug(_("An update for %(hostname)s (%(provider)s) is performed because the holdoff time has expired") %
 211                                                  {"hostname": self.hostname, "provider": self.name})
 212
 213                         return True
 214
 215                 # Otherwise, we don't need to perform an update
 216                 logger.debug(_("No update required for %(hostname)s (%(provider)s)") %
 217                                          {"hostname": self.hostname, "provider": self.name})
 218
 219                 return False
 220
 221         @property
 222         def has_failure(self):
 223                 """
 224                         Returns True when the last update has failed and no retry
 225                         should be performed, yet.
 226                 """
 227                 last_status = self.db.last_update_status(self.hostname)
 228
 229                 # Return False if the last update has not failed.
 230                 if not last_status == "failure":
 231                         return False
 232
 233                 # If there is no holdoff time, we won't update ever again.
 234                 if self.holdoff_failure_days is None:
 235                         logger.warning(_("An update has not been performed because earlier updates failed for %s") % self.hostname)
 236                         logger.warning(_("There will be no retries"))
 237
 238                         return True
 239
 240                 # Determine when the holdoff time ends
 241                 last_update = self.db.last_update(self.hostname, status=last_status)
 242                 holdoff_end = last_update + datetime.timedelta(days=self.holdoff_failure_days)
 243
 244                 now = datetime.datetime.utcnow()
 245                 if now < holdoff_end:
 246                         failure_message = self.db.last_update_failure_message(self.hostname)
 247
 248                         logger.warning(_("An update has not been performed because earlier updates failed for %s") % self.hostname)
 249
 250                         if failure_message:
 251                                 logger.warning(_("Last failure message:"))
 252
 253                                 for line in failure_message.splitlines():
 254                                         logger.warning("  %s" % line)
 255
 256                         logger.warning(_("Further updates will be withheld until %s") % holdoff_end)
 257
 258                         return True
 259
 260                 return False
 261
 262         def ip_address_changed(self, protos):
 263                 """
 264                         Returns True if this host is already up to date
 265                         and does not need to change the IP address on the
 266                         name server.
 267                 """
 268                 for proto in protos:
 269                         addresses = self.core.system.resolve(self.hostname, proto)
 270                         current_address = self.get_address(proto)
 271
 272                         # Handle if the system has not got any IP address from a protocol
 273                         # (i.e. had full dual-stack connectivity which it has not any more)
 274                         if current_address is None:
 275                                 # If addresses still exists in the DNS system and if this provider
 276                                 # is able to remove records, we will do that.
 277                                 if addresses and self.can_remove_records:
 278                                         return True
 279
 280                                 # Otherwise, we cannot go on...
 281                                 continue
 282
 283                         if not current_address in addresses:
 284                                 return True
 285
 286                 return False
 287
 288         def holdoff_time_expired(self):
 289                 """
 290                         Returns true if the holdoff time has expired
 291                         and the host requires an update
 292                 """
 293                 # If no holdoff days is defined, we cannot go on
 294                 if not self.holdoff_days:
 295                         return False
 296
 297                 # Get the timestamp of the last successfull update
 298                 last_update = self.db.last_update(self.hostname, status="success")
 299
 300                 # If no timestamp has been recorded, no update has been
 301                 # performed. An update should be performed now.
 302                 if not last_update:
 303                         return True
 304
 305                 # Determine when the holdoff time ends
 306                 holdoff_end = last_update + datetime.timedelta(days=self.holdoff_days)
 307
 308                 now = datetime.datetime.utcnow()
 309
 310                 if now >= holdoff_end:
 311                         logger.debug("The holdoff time has expired for %s" % self.hostname)
 312                         return True
 313                 else:
 314                         logger.debug("Updates for %s are held off until %s" %
 315                                                  (self.hostname, holdoff_end))
 316                         return False
 317
 318         def send_request(self, *args, **kwargs):
 319                 """
 320                         Proxy connection to the send request
 321                         method.
 322                 """
 323                 return self.core.system.send_request(*args, **kwargs)
 324
 325         def get_address(self, proto, default=None):
 326                 """
 327                         Proxy method to get the current IP address.
 328                 """
 329                 return self.core.system.get_address(proto) or default
 330
 331         def have_address(self, proto):
 332                 """
 333                         Returns True if an IP address for the given protocol
 334                         is known and usable.
 335                 """
 336                 address = self.get_address(proto)
 337
 338                 if address:
 339                         return True
 340
 341                 return False
 342
 343
 344 class DDNSProtocolDynDNS2(object):
 345         """
 346                 This is an abstract class that implements the DynDNS updater
 347                 protocol version 2. As this is a popular way to update dynamic
 348                 DNS records, this class is supposed make the provider classes
 349                 shorter and simpler.
 350         """
 351
 352         # Information about the format of the request is to be found
 353         # http://dyn.com/support/developers/api/perform-update/
 354         # http://dyn.com/support/developers/api/return-codes/
 355
 356         # The DynDNS protocol version 2 does not allow to remove records
 357         can_remove_records = False
 358
 359         # The DynDNS protocol version 2 only supports authentication via
 360         # username and password.
 361         supports_token_auth = False
 362
 363         def prepare_request_data(self, proto):
 364                 data = {
 365                         "hostname" : self.hostname,
 366                         "myip"     : self.get_address(proto),
 367                 }
 368
 369                 return data
 370
 371         def update_protocol(self, proto):
 372                 data = self.prepare_request_data(proto)
 373
 374                 return self.send_request(data)
 375
 376         def send_request(self, data):
 377                 # Send update to the server.
 378                 response = DDNSProvider.send_request(self, self.url, data=data, username=self.username, password=self.password)
 379
 380                 # Get the full response message.
 381                 output = response.read().decode()
 382
 383                 # Handle success messages.
 384                 if output.startswith("good") or output.startswith("nochg"):
 385                         return
 386
 387                 # Handle error codes.
 388                 if output == "badauth":
 389                         raise DDNSAuthenticationError
 390                 elif output == "abuse":
 391                         raise DDNSAbuseError
 392                 elif output == "notfqdn":
 393                         raise DDNSRequestError(_("No valid FQDN was given"))
 394                 elif output == "nohost":
 395                         raise DDNSRequestError(_("Specified host does not exist"))
 396                 elif output == "911":
 397                         raise DDNSInternalServerError
 398                 elif output == "dnserr":
 399                         raise DDNSInternalServerError(_("DNS error encountered"))
 400                 elif output == "badagent":
 401                         raise DDNSBlockedError
 402                 elif output == "badip":
 403                         raise DDNSBlockedError
 404
 405                 # If we got here, some other update error happened.
 406                 raise DDNSUpdateError(_("Server response: %s") % output)
 407
 408
 409 class DDNSResponseParserXML(object):
 410         """
 411                 This class provides a parser for XML responses which
 412                 will be sent by various providers. This class uses the python
 413                 shipped XML minidom module to walk through the XML tree and return
 414                 a requested element.
 415         """
 416
 417         def get_xml_tag_value(self, document, content):
 418                 # Send input to the parser.
 419                 xmldoc = xml.dom.minidom.parseString(document)
 420
 421                 # Get XML elements by the given content.
 422                 element = xmldoc.getElementsByTagName(content)
 423
 424                 # If no element has been found, we directly can return None.
 425                 if not element:
 426                         return None
 427
 428                 # Only get the first child from an element, even there are more than one.
 429                 firstchild = element[0].firstChild
 430
 431                 # Get the value of the child.
 432                 value = firstchild.nodeValue
 433
 434                 # Return the value.
 435                 return value
 436
 437
 438 class DDNSProviderAllInkl(DDNSProvider):
 439         handle    = "all-inkl.com"
 440         name      = "All-inkl.com"
 441         website   = "http://all-inkl.com/"
 442         protocols = ("ipv4",)
 443
 444         # There are only information provided by the vendor how to
 445         # perform an update on a FRITZ Box. Grab requried informations
 446         # from the net.
 447         # http://all-inkl.goetze.it/v01/ddns-mit-einfachen-mitteln/
 448
 449         url = "https://dyndns.kasserver.com"
 450         can_remove_records = False
 451         supports_token_auth = False
 452
 453         def update(self):
 454                 # There is no additional data required so we directly can
 455                 # send our request.
 456                 response = self.send_request(self.url, username=self.username, password=self.password)
 457
 458                 # Get the full response message.
 459                 output = response.read().decode()
 460
 461                 # Handle success messages.
 462                 if output.startswith("good") or output.startswith("nochg"):
 463                         return
 464
 465                 # If we got here, some other update error happened.
 466                 raise DDNSUpdateError
 467
 468
 469 class DDNSProviderBindNsupdate(DDNSProvider):
 470         handle  = "nsupdate"
 471         name    = "BIND nsupdate utility"
 472         website = "http://en.wikipedia.org/wiki/Nsupdate"
 473
 474         DEFAULT_TTL = 60
 475
 476         supports_token_auth = False
 477
 478         @staticmethod
 479         def supported():
 480                 # Search if the nsupdate utility is available
 481                 paths = os.environ.get("PATH")
 482
 483                 for path in paths.split(":"):
 484                         executable = os.path.join(path, "nsupdate")
 485
 486                         if os.path.exists(executable):
 487                                 return True
 488
 489                 return False
 490
 491         def update(self):
 492                 scriptlet = self.__make_scriptlet()
 493
 494                 # -v enables TCP hence we transfer keys and other data that may
 495                 # exceed the size of one packet.
 496                 # -t sets the timeout
 497                 command = ["nsupdate", "-v", "-t", "60"]
 498
 499                 p = subprocess.Popen(command, shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 500                 stdout, stderr = p.communicate(scriptlet)
 501
 502                 if p.returncode == 0:
 503                         return
 504
 505                 raise DDNSError("nsupdate terminated with error code: %s\n  %s" % (p.returncode, stderr))
 506
 507         def __make_scriptlet(self):
 508                 scriptlet = []
 509
 510                 # Set a different server the update is sent to.
 511                 server = self.get("server", None)
 512                 if server:
 513                         scriptlet.append("server %s" % server)
 514
 515                 # Set the DNS zone the host should be added to.
 516                 zone = self.get("zone", None)
 517                 if zone:
 518                         scriptlet.append("zone %s" % zone)
 519
 520                 key = self.get("key", None)
 521                 if key:
 522                         secret = self.get("secret")
 523
 524                         scriptlet.append("key %s %s" % (key, secret))
 525
 526                 ttl = self.get("ttl", self.DEFAULT_TTL)
 527
 528                 # Perform an update for each supported protocol.
 529                 for rrtype, proto in (("AAAA", "ipv6"), ("A", "ipv4")):
 530                         address = self.get_address(proto)
 531                         if not address:
 532                                 continue
 533
 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))
 537
 538                 # Send the actions to the server.
 539                 scriptlet.append("send")
 540                 scriptlet.append("quit")
 541
 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 **** ****"
 547
 548                         logger.debug("  %s" % line)
 549
 550                 return "\n".join(scriptlet).encode()
 551
 552
 553 class DDNSProviderChangeIP(DDNSProvider):
 554         handle    = "changeip.com"
 555         name      = "ChangeIP.com"
 556         website   = "https://changeip.com"
 557         protocols = ("ipv4",)
 558
 559         # Detailed information about the update api can be found here.
 560         # http://www.changeip.com/accounts/knowledgebase.php?action=displayarticle&id=34
 561
 562         url = "https://nic.changeip.com/nic/update"
 563         can_remove_records = False
 564         supports_token_auth = False
 565
 566         def update_protocol(self, proto):
 567                 data = {
 568                         "hostname" : self.hostname,
 569                         "myip"     : self.get_address(proto),
 570                 }
 571
 572                 # Send update to the server.
 573                 try:
 574                         response = self.send_request(self.url, username=self.username, password=self.password, data=data)
 575
 576                 # Handle error codes.
 577                 except urllib.error.HTTPError as e:
 578                         if e.code == 422:
 579                                 raise DDNSRequestError(_("Domain not found."))
 580
 581                         raise
 582
 583                 # Handle success message.
 584                 if response.code == 200:
 585                         return
 586
 587                 # If we got here, some other update error happened.
 588                 raise DDNSUpdateError(_("Server response: %s") % output)
 589
 590
 591 class DDNSProviderDesecIO(DDNSProtocolDynDNS2, DDNSProvider):
 592         handle    = "desec.io"
 593         name      = "desec.io"
 594         website   = "https://www.desec.io"
 595         protocols = ("ipv6", "ipv4",)
 596
 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.
 600
 601         url = "https://update.dedyn.io"
 602
 603         # desec.io sends the IPv6 and IPv4 address in one request
 604
 605         def update(self):
 606                 data = DDNSProtocolDynDNS2.prepare_request_data(self, "ipv4")
 607
 608                 # This one supports IPv6
 609                 myipv6 = self.get_address("ipv6")
 610
 611                 # Add update information if we have an IPv6 address.
 612                 if myipv6:
 613                         data["myipv6"] = myipv6
 614
 615                 self.send_request(data)
 616
 617
 618 class DDNSProviderDDNSS(DDNSProvider):
 619         handle    = "ddnss.de"
 620         name      = "DDNSS"
 621         website   = "http://www.ddnss.de"
 622         protocols = ("ipv4",)
 623
 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
 628
 629         url = "https://www.ddnss.de/upd.php"
 630         can_remove_records = False
 631         supports_token_auth = False
 632
 633         def update_protocol(self, proto):
 634                 data = {
 635                         "ip"   : self.get_address(proto),
 636                         "host" : self.hostname,
 637                 }
 638
 639                 # Check if a token has been set.
 640                 if self.token:
 641                         data["key"] = self.token
 642
 643                 # Check if username and hostname are given.
 644                 elif self.username and self.password:
 645                         data.update({
 646                                 "user" : self.username,
 647                                 "pwd"  : self.password,
 648                         })
 649
 650                 # Raise an error if no auth details are given.
 651                 else:
 652                         raise DDNSConfigurationError
 653
 654                 # Send update to the server.
 655                 response = self.send_request(self.url, data=data)
 656
 657                 # This provider sends the response code as part of the header.
 658                 # Get status information from the header.
 659                 output = response.getheader('ddnss-response')
 660
 661                 # Handle success messages.
 662                 if output == "good" or output == "nochg":
 663                         return
 664
 665                 # Handle error codes.
 666                 if output == "badauth":
 667                         raise DDNSAuthenticationError
 668                 elif output == "notfqdn":
 669                         raise DDNSRequestError(_("No valid FQDN was given"))
 670                 elif output == "nohost":
 671                         raise DDNSRequestError(_("Specified host does not exist"))
 672                 elif output == "911":
 673                         raise DDNSInternalServerError
 674                 elif output == "dnserr":
 675                         raise DDNSInternalServerError(_("DNS error encountered"))
 676                 elif output == "disabled":
 677                         raise DDNSRequestError(_("Account disabled or locked"))
 678
 679                 # If we got here, some other update error happened.
 680                 raise DDNSUpdateError
 681
 682
 683 class DDNSProviderDHS(DDNSProvider):
 684         handle    = "dhs.org"
 685         name      = "DHS International"
 686         website   = "http://dhs.org/"
 687         protocols = ("ipv4",)
 688
 689         # No information about the used update api provided on webpage,
 690         # grabed from source code of ez-ipudate.
 691
 692         # Provider currently does not support TLS 1.2.
 693         url = "https://members.dhs.org/nic/hosts"
 694         can_remove_records = False
 695         supports_token_auth = False
 696
 697         def update_protocol(self, proto):
 698                 data = {
 699                         "domain"       : self.hostname,
 700                         "ip"           : self.get_address(proto),
 701                         "hostcmd"      : "edit",
 702                         "hostcmdstage" : "2",
 703                         "type"         : "4",
 704                 }
 705
 706                 # Send update to the server.
 707                 response = self.send_request(self.url, username=self.username, password=self.password, data=data)
 708
 709                 # Handle success messages.
 710                 if response.code == 200:
 711                         return
 712
 713                 # If we got here, some other update error happened.
 714                 raise DDNSUpdateError
 715
 716
 717 class DDNSProviderDNSpark(DDNSProvider):
 718         handle    = "dnspark.com"
 719         name      = "DNS Park"
 720         website   = "http://dnspark.com/"
 721         protocols = ("ipv4",)
 722
 723         # Informations to the used api can be found here:
 724         # https://dnspark.zendesk.com/entries/31229348-Dynamic-DNS-API-Documentation
 725
 726         url = "https://control.dnspark.com/api/dynamic/update.php"
 727         can_remove_records = False
 728         supports_token_auth = False
 729
 730         def update_protocol(self, proto):
 731                 data = {
 732                         "domain" : self.hostname,
 733                         "ip"     : self.get_address(proto),
 734                 }
 735
 736                 # Send update to the server.
 737                 response = self.send_request(self.url, username=self.username, password=self.password, data=data)
 738
 739                 # Get the full response message.
 740                 output = response.read().decode()
 741
 742                 # Handle success messages.
 743                 if output.startswith("ok") or output.startswith("nochange"):
 744                         return
 745
 746                 # Handle error codes.
 747                 if output == "unauth":
 748                         raise DDNSAuthenticationError
 749                 elif output == "abuse":
 750                         raise DDNSAbuseError
 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"))
 761
 762                 # If we got here, some other update error happened.
 763                 raise DDNSUpdateError
 764
 765
 766 class DDNSProviderDtDNS(DDNSProvider):
 767         handle    = "dtdns.com"
 768         name      = "DtDNS"
 769         website   = "http://dtdns.com/"
 770         protocols = ("ipv4",)
 771
 772         # Information about the format of the HTTPS request is to be found
 773         # http://www.dtdns.com/dtsite/updatespec
 774
 775         url = "https://www.dtdns.com/api/autodns.cfm"
 776         can_remove_records = False
 777         supports_token_auth = False
 778
 779         def update_protocol(self, proto):
 780                 data = {
 781                         "ip" : self.get_address(proto),
 782                         "id" : self.hostname,
 783                         "pw" : self.password
 784                 }
 785
 786                 # Send update to the server.
 787                 response = self.send_request(self.url, data=data)
 788
 789                 # Get the full response message.
 790                 output = response.read().decode()
 791
 792                 # Remove all leading and trailing whitespace.
 793                 output = output.strip()
 794
 795                 # Handle success messages.
 796                 if "now points to" in output:
 797                         return
 798
 799                 # Handle error codes.
 800                 if output == "No hostname to update was supplied.":
 801                         raise DDNSRequestError(_("No hostname specified"))
 802
 803                 elif output == "The hostname you supplied is not valid.":
 804                         raise DDNSRequestError(_("Invalid hostname specified"))
 805
 806                 elif output == "The password you supplied is not valid.":
 807                         raise DDNSAuthenticationError
 808
 809                 elif output == "Administration has disabled this account.":
 810                         raise DDNSRequestError(_("Account has been disabled"))
 811
 812                 elif output == "Illegal character in IP.":
 813                         raise DDNSRequestError(_("Invalid IP address has been sent"))
 814
 815                 elif output == "Too many failed requests.":
 816                         raise DDNSRequestError(_("Too many failed requests"))
 817
 818                 # If we got here, some other update error happened.
 819                 raise DDNSUpdateError
 820
 821
 822 class DDNSProviderDuckDNS(DDNSProvider):
 823         handle    = "duckdns.org"
 824         name      = "Duck DNS"
 825         website   = "http://www.duckdns.org/"
 826         protocols = ("ipv6", "ipv4",)
 827
 828         # Information about the format of the request is to be found
 829         # https://www.duckdns.org/spec.jsp
 830
 831         url = "https://www.duckdns.org/update"
 832         can_remove_records = False
 833         supports_token_auth = True
 834
 835         def update(self):
 836                 # Raise an error if no auth details are given.
 837                 if not self.token:
 838                         raise DDNSConfigurationError
 839
 840                 data =  {
 841                         "domains" : self.hostname,
 842                         "token"    : self.token,
 843                 }
 844
 845                 # Check if we update an IPv4 address.
 846                 address4 = self.get_address("ipv4")
 847                 if address4:
 848                         data["ip"] = address4
 849
 850                 # Check if we update an IPv6 address.
 851                 address6 = self.get_address("ipv6")
 852                 if address6:
 853                         data["ipv6"] = address6
 854
 855                 # Raise an error if no address is given.
 856                 if "ip" not in data and "ipv6" not in data:
 857                         raise DDNSConfigurationError
 858
 859                 # Send update to the server.
 860                 response = self.send_request(self.url, data=data)
 861
 862                 # Get the full response message.
 863                 output = response.read().decode()
 864
 865                 # Remove all leading and trailing whitespace.
 866                 output = output.strip()
 867
 868                 # Handle success messages.
 869                 if output == "OK":
 870                         return
 871
 872                 # The provider does not give detailed information
 873                 # if the update fails. Only a "KO" will be sent back.
 874                 if output == "KO":
 875                         raise DDNSUpdateError
 876
 877                 # If we got here, some other update error happened.
 878                 raise DDNSUpdateError
 879
 880
 881 class DDNSProviderDyFi(DDNSProtocolDynDNS2, DDNSProvider):
 882         handle    = "dy.fi"
 883         name      = "dy.fi"
 884         website   = "https://www.dy.fi/"
 885         protocols = ("ipv4",)
 886
 887         # Information about the format of the request is to be found
 888         # https://www.dy.fi/page/clients?lang=en
 889         # https://www.dy.fi/page/specification?lang=en
 890
 891         url = "https://www.dy.fi/nic/update"
 892
 893         # Please only send automatic updates when your IP address changes,
 894         # or once per 5 to 6 days to refresh the address mapping (they will
 895         # expire if not refreshed within 7 days).
 896         holdoff_days = 6
 897
 898
 899 class DDNSProviderDynDNS(DDNSProtocolDynDNS2, DDNSProvider):
 900         handle    = "dyndns.org"
 901         name      = "Dyn"
 902         website   = "http://dyn.com/dns/"
 903         protocols = ("ipv4",)
 904
 905         # Information about the format of the request is to be found
 906         # http://http://dyn.com/support/developers/api/perform-update/
 907         # http://dyn.com/support/developers/api/return-codes/
 908
 909         url = "https://members.dyndns.org/nic/update"
 910
 911
 912 class DDNSProviderDomainOffensive(DDNSProtocolDynDNS2, DDNSProvider):
 913         handle    = "do.de"
 914         name      = "Domain-Offensive"
 915         website   = "https://www.do.de/"
 916         protocols = ("ipv6", "ipv4")
 917
 918         # Detailed information about the request and response codes
 919         # are available on the providers webpage.
 920         # https://www.do.de/wiki/FlexDNS_-_Entwickler
 921
 922         url = "https://ddns.do.de/"
 923
 924 class DDNSProviderDynUp(DDNSProvider):
 925         handle    = "dynup.de"
 926         name      = "DynUp.DE"
 927         website   = "http://dynup.de/"
 928         protocols = ("ipv4",)
 929
 930         # Information about the format of the HTTPS request is to be found
 931         # https://dyndnsfree.de/user/hilfe.php
 932
 933         url = "https://dynup.de/dyn.php"
 934         can_remove_records = False
 935         supports_token_auth = False
 936
 937         def update_protocol(self, proto):
 938                 data = {
 939                         "username" : self.username,
 940                         "password" : self.password,
 941                         "hostname" : self.hostname,
 942                         "print" : '1',
 943                 }
 944
 945                 # Send update to the server.
 946                 response = self.send_request(self.url, data=data)
 947
 948                 # Get the full response message.
 949                 output = response.read().decode()
 950
 951                 # Remove all leading and trailing whitespace.
 952                 output = output.strip()
 953
 954                 # Handle success messages.
 955                 if output.startswith("I:OK"):
 956                         return
 957
 958                 # If we got here, some other update error happened.
 959                 raise DDNSUpdateError
 960
 961
 962 class DDNSProviderDynU(DDNSProtocolDynDNS2, DDNSProvider):
 963         handle    = "dynu.com"
 964         name      = "Dynu"
 965         website   = "http://dynu.com/"
 966         protocols = ("ipv6", "ipv4",)
 967
 968         # Detailed information about the request and response codes
 969         # are available on the providers webpage.
 970         # http://dynu.com/Default.aspx?page=dnsapi
 971
 972         url = "https://api.dynu.com/nic/update"
 973
 974         # DynU sends the IPv6 and IPv4 address in one request
 975
 976         def update(self):
 977                 data = DDNSProtocolDynDNS2.prepare_request_data(self, "ipv4")
 978
 979                 # This one supports IPv6
 980                 myipv6 = self.get_address("ipv6")
 981
 982                 # Add update information if we have an IPv6 address.
 983                 if myipv6:
 984                         data["myipv6"] = myipv6
 985
 986                 self.send_request(data)
 987
 988
 989 class DDNSProviderEasyDNS(DDNSProvider):
 990         handle    = "easydns.com"
 991         name      = "EasyDNS"
 992         website   = "http://www.easydns.com/"
 993         protocols = ("ipv4",)
 994
 995         # Detailed information about the request and response codes
 996         # (API 1.3) are available on the providers webpage.
 997         # https://fusion.easydns.com/index.php?/Knowledgebase/Article/View/102/7/dynamic-dns
 998
 999         url = "https://api.cp.easydns.com/dyn/tomato.php"
1000
1001         supports_token_auth = False
1002
1003         def update_protocol(self, proto):
1004                 data = {
1005                         "myip"     : self.get_address(proto, "-"),
1006                         "hostname" : self.hostname,
1007                 }
1008
1009                 # Send update to the server.
1010                 response = self.send_request(self.url, data=data, username=self.username, password=self.password)
1011
1012                 # Get the full response message.
1013                 output = response.read().decode()
1014
1015                 # Remove all leading and trailing whitespace.
1016                 output = output.strip()
1017
1018                 # Handle success messages.
1019                 if output.startswith("NOERROR"):
1020                         return
1021
1022                 # Handle error codes.
1023                 if output.startswith("NOACCESS"):
1024                         raise DDNSAuthenticationError
1025
1026                 elif output.startswith("NOSERVICE"):
1027                         raise DDNSRequestError(_("Dynamic DNS is not turned on for this domain"))
1028
1029                 elif output.startswith("ILLEGAL INPUT"):
1030                         raise DDNSRequestError(_("Invalid data has been sent"))
1031
1032                 elif output.startswith("TOOSOON"):
1033                         raise DDNSRequestError(_("Too frequent update requests have been sent"))
1034
1035                 # If we got here, some other update error happened.
1036                 raise DDNSUpdateError
1037
1038
1039 class DDNSProviderDomopoli(DDNSProtocolDynDNS2, DDNSProvider):
1040         handle    = "domopoli.de"
1041         name      = "domopoli.de"
1042         website   = "http://domopoli.de/"
1043         protocols = ("ipv4",)
1044
1045         # https://www.domopoli.de/?page=howto#DynDns_start
1046
1047         # This provider does not support TLS 1.2.
1048         url = "https://dyndns.domopoli.de/nic/update"
1049
1050
1051 class DDNSProviderDynsNet(DDNSProvider):
1052         handle    = "dyns.net"
1053         name      = "DyNS"
1054         website   = "http://www.dyns.net/"
1055         protocols = ("ipv4",)
1056         can_remove_records = False
1057         supports_token_auth = False
1058
1059         # There is very detailed informatio about how to send the update request and
1060         # the possible response codes. (Currently we are using the v1.1 proto)
1061         # http://www.dyns.net/documentation/technical/protocol/
1062
1063         url = "https://www.dyns.net/postscript011.php"
1064
1065         def update_protocol(self, proto):
1066                 data = {
1067                         "ip"       : self.get_address(proto),
1068                         "host"     : self.hostname,
1069                         "username" : self.username,
1070                         "password" : self.password,
1071                 }
1072
1073                 # Send update to the server.
1074                 response = self.send_request(self.url, data=data)
1075
1076                 # Get the full response message.
1077                 output = response.read().decode()
1078
1079                 # Handle success messages.
1080                 if output.startswith("200"):
1081                         return
1082
1083                 # Handle error codes.
1084                 if output.startswith("400"):
1085                         raise DDNSRequestError(_("Malformed request has been sent"))
1086                 elif output.startswith("401"):
1087                         raise DDNSAuthenticationError
1088                 elif output.startswith("402"):
1089                         raise DDNSRequestError(_("Too frequent update requests have been sent"))
1090                 elif output.startswith("403"):
1091                         raise DDNSInternalServerError
1092
1093                 # If we got here, some other update error happened.
1094                 raise DDNSUpdateError(_("Server response: %s") % output)
1095
1096
1097 class DDNSProviderEnomCom(DDNSResponseParserXML, DDNSProvider):
1098         handle    = "enom.com"
1099         name      = "eNom Inc."
1100         website   = "http://www.enom.com/"
1101         protocols = ("ipv4",)
1102
1103         # There are very detailed information about how to send an update request and
1104         # the respone codes.
1105         # http://www.enom.com/APICommandCatalog/
1106
1107         url = "https://dynamic.name-services.com/interface.asp"
1108         can_remove_records = False
1109         supports_token_auth = False
1110
1111         def update_protocol(self, proto):
1112                 data = {
1113                         "command"        : "setdnshost",
1114                         "responsetype"   : "xml",
1115                         "address"        : self.get_address(proto),
1116                         "domainpassword" : self.password,
1117                         "zone"           : self.hostname
1118                 }
1119
1120                 # Send update to the server.
1121                 response = self.send_request(self.url, data=data)
1122
1123                 # Get the full response message.
1124                 output = response.read().decode()
1125
1126                 # Handle success messages.
1127                 if self.get_xml_tag_value(output, "ErrCount") == "0":
1128                         return
1129
1130                 # Handle error codes.
1131                 errorcode = self.get_xml_tag_value(output, "ResponseNumber")
1132
1133                 if errorcode == "304155":
1134                         raise DDNSAuthenticationError
1135                 elif errorcode == "304153":
1136                         raise DDNSRequestError(_("Domain not found"))
1137
1138                 # If we got here, some other update error happened.
1139                 raise DDNSUpdateError
1140
1141
1142 class DDNSProviderEntryDNS(DDNSProvider):
1143         handle    = "entrydns.net"
1144         name      = "EntryDNS"
1145         website   = "http://entrydns.net/"
1146         protocols = ("ipv4",)
1147
1148         # Some very tiny details about their so called "Simple API" can be found
1149         # here: https://entrydns.net/help
1150         url = "https://entrydns.net/records/modify"
1151         can_remove_records = False
1152         supports_token_auth = True
1153
1154         def update_protocol(self, proto):
1155                 data = {
1156                         "ip" : self.get_address(proto),
1157                 }
1158
1159                 # Add auth token to the update url.
1160                 url = "%s/%s" % (self.url, self.token)
1161
1162                 # Send update to the server.
1163                 try:
1164                         response = self.send_request(url, data=data)
1165
1166                 # Handle error codes
1167                 except urllib.error.HTTPError as e:
1168                         if e.code == 404:
1169                                 raise DDNSAuthenticationError
1170
1171                         elif e.code == 422:
1172                                 raise DDNSRequestError(_("An invalid IP address was submitted"))
1173
1174                         raise
1175
1176                 # Handle success messages.
1177                 if response.code == 200:
1178                         return
1179
1180                 # If we got here, some other update error happened.
1181                 raise DDNSUpdateError
1182
1183
1184 class DDNSProviderFreeDNSAfraidOrg(DDNSProvider):
1185         handle    = "freedns.afraid.org"
1186         name      = "freedns.afraid.org"
1187         website   = "http://freedns.afraid.org/"
1188
1189         # No information about the request or response could be found on the vendor
1190         # page. All used values have been collected by testing.
1191         url = "https://sync.afraid.org/u/"
1192         can_remove_records = False
1193         supports_token_auth = True
1194
1195         def update_protocol(self, proto):
1196
1197                 # Add auth token to the update url.
1198                 url = "%s%s/" % (self.url, self.token)
1199
1200                 # Send update to the server.
1201                 response = self.send_request(url)
1202
1203                 # Get the full response message.
1204                 output = response.read().decode()
1205
1206                 # Handle success messages.
1207                 if output.startswith("Updated") or output.startswith("No IP change detected"):
1208                         return
1209
1210                 # Handle error codes.
1211                 if output == "ERROR: Unable to locate this record":
1212                         raise DDNSAuthenticationError
1213                 elif "is an invalid IP address" in output:
1214                         raise DDNSRequestError(_("Invalid IP address has been sent"))
1215
1216                 # If we got here, some other update error happened.
1217                 raise DDNSUpdateError
1218
1219
1220 class DDNSProviderHENet(DDNSProtocolDynDNS2, DDNSProvider):
1221                 handle    = "he.net"
1222                 name      = "he.net"
1223                 website   = "https://he.net"
1224                 protocols = ("ipv6", "ipv4",)
1225
1226                 # Detailed information about the update api can be found here.
1227                 # http://dns.he.net/docs.html
1228
1229                 url = "https://dyn.dns.he.net/nic/update"
1230                 @property
1231                 def username(self):
1232                         return self.get("hostname")
1233
1234
1235
1236 class DDNSProviderItsdns(DDNSProtocolDynDNS2, DDNSProvider):
1237                 handle    = "inwx.com"
1238                 name      = "INWX"
1239                 website   = "https://www.inwx.com"
1240                 protocols = ("ipv6", "ipv4")
1241
1242                 # Information about the format of the HTTP request is to be found
1243                 # here: https://www.inwx.com/en/nameserver2/dyndns (requires login)
1244                 # Notice: The URL is the same for: inwx.com|de|at|ch|es
1245
1246                 url = "https://dyndns.inwx.com/nic/update"
1247
1248
1249 class DDNSProviderItsdns(DDNSProtocolDynDNS2, DDNSProvider):
1250                 handle    = "itsdns.de"
1251                 name      = "it's DNS"
1252                 website   = "http://www.itsdns.de/"
1253                 protocols = ("ipv6", "ipv4")
1254
1255                 # Information about the format of the HTTP request is to be found
1256                 # here: https://www.itsdns.de/dynupdatehelp.htm
1257
1258                 url = "https://www.itsdns.de/update.php"
1259
1260
1261 class DDNSProviderJoker(DDNSProtocolDynDNS2, DDNSProvider):
1262                 handle  = "joker.com"
1263                 name    = "Joker.com Dynamic DNS"
1264                 website = "https://joker.com/"
1265                 protocols = ("ipv4",)
1266
1267                 # Information about the request can be found here:
1268                 # https://joker.com/faq/content/11/427/en/what-is-dynamic-dns-dyndns.html
1269                 # Using DynDNS V2 protocol over HTTPS here
1270
1271                 url = "https://svc.joker.com/nic/update"
1272
1273
1274 class DDNSProviderKEYSYSTEMS(DDNSProvider):
1275         handle    = "key-systems.net"
1276         name      = "dynamicdns.key-systems.net"
1277         website   = "https://domaindiscount24.com/"
1278         protocols = ("ipv4",)
1279
1280         # There are only information provided by the domaindiscount24 how to
1281         # perform an update with HTTP APIs
1282         # https://www.domaindiscount24.com/faq/dynamic-dns
1283         # examples: https://dynamicdns.key-systems.net/update.php?hostname=hostname&password=password&ip=auto
1284         #           https://dynamicdns.key-systems.net/update.php?hostname=hostname&password=password&ip=213.x.x.x&mx=213.x.x.x
1285
1286         url = "https://dynamicdns.key-systems.net/update.php"
1287         can_remove_records = False
1288         supports_token_auth = False
1289
1290         def update_protocol(self, proto):
1291                 address = self.get_address(proto)
1292                 data = {
1293                         "hostname"      : self.hostname,
1294                         "password"      : self.password,
1295                         "ip"            : address,
1296                 }
1297
1298                 # Send update to the server.
1299                 response = self.send_request(self.url, data=data)
1300
1301                 # Get the full response message.
1302                 output = response.read().decode()
1303
1304                 # Handle success messages.
1305                 if "code = 200" in output:
1306                         return
1307
1308                 # Handle error messages.
1309                 if "abuse prevention triggered" in output:
1310                         raise DDNSAbuseError
1311                 elif "invalid password" in output:
1312                         raise DDNSAuthenticationError
1313                 elif "Authorization failed" in output:
1314                         raise DDNSRequestError(_("Invalid hostname specified"))
1315
1316                 # If we got here, some other update error happened.
1317                 raise DDNSUpdateError
1318
1319
1320 class DDNSProviderGoogle(DDNSProtocolDynDNS2, DDNSProvider):
1321         handle    = "domains.google.com"
1322         name      = "Google Domains"
1323         website   = "https://domains.google.com/"
1324         protocols = ("ipv4",)
1325
1326         # Information about the format of the HTTP request is to be found
1327         # here: https://support.google.com/domains/answer/6147083?hl=en
1328
1329         url = "https://domains.google.com/nic/update"
1330
1331
1332 class DDNSProviderLightningWireLabs(DDNSProvider):
1333         handle    = "dns.lightningwirelabs.com"
1334         name      = "Lightning Wire Labs DNS Service"
1335         website   = "https://dns.lightningwirelabs.com/"
1336
1337         # Information about the format of the HTTPS request is to be found
1338         # https://dns.lightningwirelabs.com/knowledge-base/api/ddns
1339
1340         supports_token_auth = True
1341
1342         url = "https://dns.lightningwirelabs.com/update"
1343
1344         def update(self):
1345                 # Raise an error if no auth details are given.
1346                 if not self.token:
1347                         raise DDNSConfigurationError
1348
1349                 data =  {
1350                         "hostname" : self.hostname,
1351                         "token"    : self.token,
1352                         "address6" : self.get_address("ipv6", "-"),
1353                         "address4" : self.get_address("ipv4", "-"),
1354                 }
1355
1356                 # Send update to the server.
1357                 response = self.send_request(self.url, data=data)
1358
1359                 # Handle success messages.
1360                 if response.code == 200:
1361                         return
1362
1363                 # If we got here, some other update error happened.
1364                 raise DDNSUpdateError
1365
1366
1367 class DDNSProviderLoopia(DDNSProtocolDynDNS2, DDNSProvider):
1368         handle    = "loopia.se"
1369         name      = "Loopia AB"
1370         website   = "https://www.loopia.com"
1371         protocols = ("ipv4",)
1372
1373         # Information about the format of the HTTP request is to be found
1374         # here: https://support.loopia.com/wiki/About_the_DynDNS_support
1375
1376         url = "https://dns.loopia.se/XDynDNSServer/XDynDNS.php"
1377
1378
1379 class DDNSProviderMyOnlinePortal(DDNSProtocolDynDNS2, DDNSProvider):
1380         handle    = "myonlineportal.net"
1381         name      = "myonlineportal.net"
1382         website   = "https:/myonlineportal.net/"
1383
1384         # Information about the request and response can be obtained here:
1385         # https://myonlineportal.net/howto_dyndns
1386
1387         url = "https://myonlineportal.net/updateddns"
1388
1389         def prepare_request_data(self, proto):
1390                 data = {
1391                         "hostname" : self.hostname,
1392                         "ip"     : self.get_address(proto),
1393                 }
1394
1395                 return data
1396
1397
1398 class DDNSProviderNamecheap(DDNSResponseParserXML, DDNSProvider):
1399         handle    = "namecheap.com"
1400         name      = "Namecheap"
1401         website   = "http://namecheap.com"
1402         protocols = ("ipv4",)
1403
1404         # Information about the format of the HTTP request is to be found
1405         # https://www.namecheap.com/support/knowledgebase/article.aspx/9249/0/nc-dynamic-dns-to-dyndns-adapter
1406         # https://community.namecheap.com/forums/viewtopic.php?f=6&t=6772
1407
1408         url = "https://dynamicdns.park-your-domain.com/update"
1409         can_remove_records = False
1410         supports_token_auth = False
1411
1412         def update_protocol(self, proto):
1413                 # Namecheap requires the hostname splitted into a host and domain part.
1414                 host, domain = self.hostname.split(".", 1)
1415
1416                 # Get and store curent IP address.
1417                 address = self.get_address(proto)
1418
1419                 data = {
1420                         "ip"       : address,
1421                         "password" : self.password,
1422                         "host"     : host,
1423                         "domain"   : domain
1424                 }
1425
1426                 # Send update to the server.
1427                 response = self.send_request(self.url, data=data)
1428
1429                 # Get the full response message.
1430                 output = response.read().decode()
1431
1432                 # Handle success messages.
1433                 if self.get_xml_tag_value(output, "IP") == address:
1434                         return
1435
1436                 # Handle error codes.
1437                 errorcode = self.get_xml_tag_value(output, "ResponseNumber")
1438
1439                 if errorcode == "304156":
1440                         raise DDNSAuthenticationError
1441                 elif errorcode == "316153":
1442                         raise DDNSRequestError(_("Domain not found"))
1443                 elif errorcode == "316154":
1444                         raise DDNSRequestError(_("Domain not active"))
1445                 elif errorcode in ("380098", "380099"):
1446                         raise DDNSInternalServerError
1447
1448                 # If we got here, some other update error happened.
1449                 raise DDNSUpdateError
1450
1451
1452 class DDNSProviderNOIP(DDNSProtocolDynDNS2, DDNSProvider):
1453         handle    = "no-ip.com"
1454         name      = "NoIP"
1455         website   = "http://www.noip.com/"
1456         protocols = ("ipv4",)
1457
1458         # Information about the format of the HTTP request is to be found
1459         # here: http://www.noip.com/integrate/request and
1460         # here: http://www.noip.com/integrate/response
1461
1462         url = "https://dynupdate.noip.com/nic/update"
1463
1464         def prepare_request_data(self, proto):
1465                 assert proto == "ipv4"
1466
1467                 data = {
1468                         "hostname" : self.hostname,
1469                         "address"  : self.get_address(proto),
1470                 }
1471
1472                 return data
1473
1474
1475 class DDNSProviderNowDNS(DDNSProtocolDynDNS2, DDNSProvider):
1476         handle    = "now-dns.com"
1477         name      = "NOW-DNS"
1478         website   = "http://now-dns.com/"
1479         protocols = ("ipv6", "ipv4")
1480
1481         # Information about the format of the request is to be found
1482         # but only can be accessed by register an account and login
1483         # https://now-dns.com/?m=api
1484
1485         url = "https://now-dns.com/update"
1486
1487
1488 class DDNSProviderNsupdateINFO(DDNSProtocolDynDNS2, DDNSProvider):
1489         handle    = "nsupdate.info"
1490         name      = "nsupdate.info"
1491         website   = "http://nsupdate.info/"
1492         protocols = ("ipv6", "ipv4",)
1493
1494         # Information about the format of the HTTP request can be found
1495         # after login on the provider user interface and here:
1496         # http://nsupdateinfo.readthedocs.org/en/latest/user.html
1497
1498         url = "https://nsupdate.info/nic/update"
1499
1500         # TODO nsupdate.info can actually do this, but the functionality
1501         # has not been implemented here, yet.
1502         can_remove_records = False
1503
1504         supports_token_auth = True
1505
1506         # After a failed update, there will be no retries
1507         # https://bugzilla.ipfire.org/show_bug.cgi?id=10603
1508         holdoff_failure_days = None
1509
1510         # Nsupdate.info uses the hostname as user part for the HTTP basic auth,
1511         # and for the password a so called secret.
1512         @property
1513         def username(self):
1514                 return self.get("hostname")
1515
1516         @property
1517         def password(self):
1518                 return self.token or self.get("secret")
1519
1520         def prepare_request_data(self, proto):
1521                 data = {
1522                         "myip" : self.get_address(proto),
1523                 }
1524
1525                 return data
1526
1527
1528 class DDNSProviderOpenDNS(DDNSProtocolDynDNS2, DDNSProvider):
1529         handle    = "opendns.com"
1530         name      = "OpenDNS"
1531         website   = "http://www.opendns.com"
1532
1533         # Detailed information about the update request and possible
1534         # response codes can be obtained from here:
1535         # https://support.opendns.com/entries/23891440
1536
1537         url = "https://updates.opendns.com/nic/update"
1538
1539         def prepare_request_data(self, proto):
1540                 data = {
1541                         "hostname" : self.hostname,
1542                         "myip"     : self.get_address(proto),
1543                 }
1544
1545                 return data
1546
1547
1548 class DDNSProviderOVH(DDNSProtocolDynDNS2, DDNSProvider):
1549         handle    = "ovh.com"
1550         name      = "OVH"
1551         website   = "http://www.ovh.com/"
1552         protocols = ("ipv4",)
1553
1554         # OVH only provides very limited information about how to
1555         # update a DynDNS host. They only provide the update url
1556         # on the their german subpage.
1557         #
1558         # http://hilfe.ovh.de/DomainDynHost
1559
1560         url = "https://www.ovh.com/nic/update"
1561
1562         def prepare_request_data(self, proto):
1563                 data = DDNSProtocolDynDNS2.prepare_request_data(self, proto)
1564                 data.update({
1565                         "system" : "dyndns",
1566                 })
1567
1568                 return data
1569
1570
1571 class DDNSProviderRegfish(DDNSProvider):
1572         handle  = "regfish.com"
1573         name    = "Regfish GmbH"
1574         website = "http://www.regfish.com/"
1575
1576         # A full documentation to the providers api can be found here
1577         # but is only available in german.
1578         # https://www.regfish.de/domains/dyndns/dokumentation
1579
1580         url = "https://dyndns.regfish.de/"
1581         can_remove_records = False
1582         supports_token_auth = True
1583
1584         def update(self):
1585                 data = {
1586                         "fqdn" : self.hostname,
1587                 }
1588
1589                 # Check if we update an IPv6 address.
1590                 address6 = self.get_address("ipv6")
1591                 if address6:
1592                         data["ipv6"] = address6
1593
1594                 # Check if we update an IPv4 address.
1595                 address4 = self.get_address("ipv4")
1596                 if address4:
1597                         data["ipv4"] = address4
1598
1599                 # Raise an error if none address is given.
1600                 if "ipv6" not in data and "ipv4" not in data:
1601                         raise DDNSConfigurationError
1602
1603                 # Check if a token has been set.
1604                 if self.token:
1605                         data["token"] = self.token
1606
1607                 # Raise an error if no token and no useranem and password
1608                 # are given.
1609                 elif not self.username and not self.password:
1610                         raise DDNSConfigurationError(_("No Auth details specified"))
1611
1612                 # HTTP Basic Auth is only allowed if no token is used.
1613                 if self.token:
1614                         # Send update to the server.
1615                         response = self.send_request(self.url, data=data)
1616                 else:
1617                         # Send update to the server.
1618                         response = self.send_request(self.url, username=self.username, password=self.password, data=data)
1619
1620                 # Get the full response message.
1621                 output = response.read().decode()
1622
1623                 # Handle success messages.
1624                 if "100" in output or "101" in output:
1625                         return
1626
1627                 # Handle error codes.
1628                 if "401" or "402" in output:
1629                         raise DDNSAuthenticationError
1630                 elif "408" in output:
1631                         raise DDNSRequestError(_("Invalid IPv4 address has been sent"))
1632                 elif "409" in output:
1633                         raise DDNSRequestError(_("Invalid IPv6 address has been sent"))
1634                 elif "412" in output:
1635                         raise DDNSRequestError(_("No valid FQDN was given"))
1636                 elif "414" in output:
1637                         raise DDNSInternalServerError
1638
1639                 # If we got here, some other update error happened.
1640                 raise DDNSUpdateError
1641
1642
1643 class DDNSProviderSchokokeksDNS(DDNSProtocolDynDNS2, DDNSProvider):
1644         handle    = "schokokeks.org"
1645         name      = "Schokokeks"
1646         website   = "http://www.schokokeks.org/"
1647         protocols = ("ipv4",)
1648
1649         # Information about the format of the request is to be found
1650         # https://wiki.schokokeks.org/DynDNS
1651         url = "https://dyndns.schokokeks.org/nic/update"
1652
1653
1654 class DDNSProviderSelfhost(DDNSProtocolDynDNS2, DDNSProvider):
1655         handle    = "selfhost.de"
1656         name      = "Selfhost.de"
1657         website   = "http://www.selfhost.de/"
1658         protocols = ("ipv4",)
1659
1660         url = "https://carol.selfhost.de/nic/update"
1661
1662         def prepare_request_data(self, proto):
1663                 data = DDNSProtocolDynDNS2.prepare_request_data(self, proto)
1664                 data.update({
1665                         "hostname" : "1",
1666                 })
1667
1668                 return data
1669
1670
1671 class DDNSProviderServercow(DDNSProvider):
1672         handle    = "servercow.de"
1673         name      = "servercow.de"
1674         website   = "https://servercow.de/"
1675         protocols = ("ipv4", "ipv6")
1676
1677         url = "https://www.servercow.de/dnsupdate/update.php"
1678         can_remove_records = False
1679         supports_token_auth = False
1680
1681         def update_protocol(self, proto):
1682                 data = {
1683                         "ipaddr"   : self.get_address(proto),
1684                         "hostname" : self.hostname,
1685                         "username" : self.username,
1686                         "pass"     : self.password,
1687                 }
1688
1689                 # Send request to provider
1690                 response = self.send_request(self.url, data=data)
1691
1692                 # Read response
1693                 output = response.read().decode()
1694
1695                 # Server responds with OK if update was successful
1696                 if output.startswith("OK"):
1697                         return
1698
1699                 # Catch any errors
1700                 elif output.startswith("FAILED - Authentication failed"):
1701                         raise DDNSAuthenticationError
1702
1703                 # If we got here, some other update error happened
1704                 raise DDNSUpdateError(output)
1705
1706
1707 class DDNSProviderSPDNS(DDNSProtocolDynDNS2, DDNSProvider):
1708         handle    = "spdns.org"
1709         name      = "SPDYN"
1710         website   = "https://www.spdyn.de/"
1711
1712         # Detailed information about request and response codes are provided
1713         # by the vendor. They are using almost the same mechanism and status
1714         # codes as dyndns.org so we can inherit all those stuff.
1715         #
1716         # http://wiki.securepoint.de/index.php/SPDNS_FAQ
1717         # http://wiki.securepoint.de/index.php/SPDNS_Update-Tokens
1718
1719         url = "https://update.spdyn.de/nic/update"
1720
1721         supports_token_auth = True
1722
1723         @property
1724         def username(self):
1725                 return self.get("username") or self.hostname
1726
1727         @property
1728         def password(self):
1729                 return self.get("password") or self.token
1730
1731
1732 class DDNSProviderStrato(DDNSProtocolDynDNS2, DDNSProvider):
1733         handle    = "strato.com"
1734         name      = "Strato AG"
1735         website   = "http:/www.strato.com/"
1736         protocols = ("ipv4",)
1737
1738         # Information about the request and response can be obtained here:
1739         # http://www.strato-faq.de/article/671/So-einfach-richten-Sie-DynDNS-f%C3%BCr-Ihre-Domains-ein.html
1740
1741         url = "https://dyndns.strato.com/nic/update"
1742
1743         def prepare_request_data(self, proto):
1744                 data = DDNSProtocolDynDNS2.prepare_request_data(self, proto)
1745                 data.update({
1746                         "mx" : "NOCHG",
1747                         "backupmx" : "NOCHG"
1748                 })
1749
1750                 return data
1751
1752
1753 class DDNSProviderTwoDNS(DDNSProtocolDynDNS2, DDNSProvider):
1754         handle    = "twodns.de"
1755         name      = "TwoDNS"
1756         website   = "http://www.twodns.de"
1757         protocols = ("ipv4",)
1758
1759         # Detailed information about the request can be found here
1760         # http://twodns.de/en/faqs
1761         # http://twodns.de/en/api
1762
1763         url = "https://update.twodns.de/update"
1764
1765         def prepare_request_data(self, proto):
1766                 assert proto == "ipv4"
1767
1768                 data = {
1769                         "ip"       : self.get_address(proto),
1770                         "hostname" : self.hostname
1771                 }
1772
1773                 return data
1774
1775
1776 class DDNSProviderUdmedia(DDNSProtocolDynDNS2, DDNSProvider):
1777         handle    = "udmedia.de"
1778         name      = "Udmedia GmbH"
1779         website   = "http://www.udmedia.de"
1780         protocols = ("ipv4",)
1781
1782         # Information about the request can be found here
1783         # http://www.udmedia.de/faq/content/47/288/de/wie-lege-ich-einen-dyndns_eintrag-an.html
1784
1785         url = "https://www.udmedia.de/nic/update"
1786
1787
1788 class DDNSProviderVariomedia(DDNSProtocolDynDNS2, DDNSProvider):
1789         handle    = "variomedia.de"
1790         name      = "Variomedia"
1791         website   = "http://www.variomedia.de/"
1792         protocols = ("ipv6", "ipv4",)
1793
1794         # Detailed information about the request can be found here
1795         # https://dyndns.variomedia.de/
1796
1797         url = "https://dyndns.variomedia.de/nic/update"
1798
1799         def prepare_request_data(self, proto):
1800                 data = {
1801                         "hostname" : self.hostname,
1802                         "myip"     : self.get_address(proto),
1803                 }
1804
1805                 return data
1806
1807
1808 class DDNSProviderXLhost(DDNSProtocolDynDNS2, DDNSProvider):
1809         handle    = "xlhost.de"
1810         name      = "XLhost"
1811         website   = "http://xlhost.de/"
1812         protocols = ("ipv4",)
1813
1814         # Information about the format of the HTTP request is to be found
1815         # here: https://xlhost.de/faq/index_html?topicId=CQA2ELIPO4SQ
1816
1817         url = "https://nsupdate.xlhost.de/"
1818
1819
1820 class DDNSProviderZoneedit(DDNSProvider):
1821         handle    = "zoneedit.com"
1822         name      = "Zoneedit"
1823         website   = "http://www.zoneedit.com"
1824         protocols = ("ipv4",)
1825
1826         supports_token_auth = False
1827
1828         # Detailed information about the request and the response codes can be
1829         # obtained here:
1830         # http://www.zoneedit.com/doc/api/other.html
1831         # http://www.zoneedit.com/faq.html
1832
1833         url = "https://dynamic.zoneedit.com/auth/dynamic.html"
1834
1835         def update_protocol(self, proto):
1836                 data = {
1837                         "dnsto" : self.get_address(proto),
1838                         "host"  : self.hostname
1839                 }
1840
1841                 # Send update to the server.
1842                 response = self.send_request(self.url, username=self.username, password=self.password, data=data)
1843
1844                 # Get the full response message.
1845                 output = response.read().decode()
1846
1847                 # Handle success messages.
1848                 if output.startswith("<SUCCESS"):
1849                         return
1850
1851                 # Handle error codes.
1852                 if output.startswith("invalid login"):
1853                         raise DDNSAuthenticationError
1854                 elif output.startswith("<ERROR CODE=\"704\""):
1855                         raise DDNSRequestError(_("No valid FQDN was given"))
1856                 elif output.startswith("<ERROR CODE=\"702\""):
1857                         raise DDNSRequestError(_("Too frequent update requests have been sent"))
1858
1859                 # If we got here, some other update error happened.
1860                 raise DDNSUpdateError
1861
1862
1863 class DDNSProviderDNSmadeEasy(DDNSProvider):
1864         handle    = "dnsmadeeasy.com"
1865         name      = "DNSmadeEasy.com"
1866         website   = "http://www.dnsmadeeasy.com/"
1867         protocols = ("ipv4",)
1868
1869         # DNS Made Easy Nameserver Provider also offering Dynamic DNS
1870         # Documentation can be found here:
1871         # http://www.dnsmadeeasy.com/dynamic-dns/
1872
1873         url = "https://cp.dnsmadeeasy.com/servlet/updateip?"
1874         can_remove_records = False
1875         supports_token_auth = False
1876
1877         def update_protocol(self, proto):
1878                 data = {
1879                         "ip" : self.get_address(proto),
1880                         "id" : self.hostname,
1881                         "username" : self.username,
1882                         "password" : self.password,
1883                 }
1884
1885                 # Send update to the server.
1886                 response = self.send_request(self.url, data=data)
1887
1888                 # Get the full response message.
1889                 output = response.read().decode()
1890
1891                 # Handle success messages.
1892                 if output.startswith("success") or output.startswith("error-record-ip-same"):
1893                         return
1894
1895                 # Handle error codes.
1896                 if output.startswith("error-auth-suspend"):
1897                         raise DDNSRequestError(_("Account has been suspended"))
1898
1899                 elif output.startswith("error-auth-voided"):
1900                         raise DDNSRequestError(_("Account has been revoked"))
1901
1902                 elif output.startswith("error-record-invalid"):
1903                         raise DDNSRequestError(_("Specified host does not exist"))
1904
1905                 elif output.startswith("error-auth"):
1906                         raise DDNSAuthenticationError
1907
1908                 # If we got here, some other update error happened.
1909                 raise DDNSUpdateError(_("Server response: %s") % output)
1910
1911
1912 class DDNSProviderZZZZ(DDNSProvider):
1913         handle    = "zzzz.io"
1914         name      = "zzzz"
1915         website   = "https://zzzz.io"
1916         protocols = ("ipv6", "ipv4",)
1917
1918         # Detailed information about the update request can be found here:
1919         # https://zzzz.io/faq/
1920
1921         # Details about the possible response codes have been provided in the bugtracker:
1922         # https://bugzilla.ipfire.org/show_bug.cgi?id=10584#c2
1923
1924         url = "https://zzzz.io/api/v1/update"
1925         can_remove_records = False
1926         supports_token_auth = True
1927
1928         def update_protocol(self, proto):
1929                 data = {
1930                         "ip"    : self.get_address(proto),
1931                         "token" : self.token,
1932                 }
1933
1934                 if proto == "ipv6":
1935                         data["type"] = "aaaa"
1936
1937                 # zzzz uses the host from the full hostname as part
1938                 # of the update url.
1939                 host, domain = self.hostname.split(".", 1)
1940
1941                 # Add host value to the update url.
1942                 url = "%s/%s" % (self.url, host)
1943
1944                 # Send update to the server.
1945                 try:
1946                         response = self.send_request(url, data=data)
1947
1948                 # Handle error codes.
1949                 except DDNSNotFound:
1950                         raise DDNSRequestError(_("Invalid hostname specified"))
1951
1952                 # Handle success messages.
1953                 if response.code == 200:
1954                         return
1955
1956                 # If we got here, some other update error happened.
1957                 raise DDNSUpdateError