src/ddns/providers.py

   1 #!/usr/bin/python
   2 ###############################################################################
   3 #                                                                             #
   4 # ddns - A dynamic DNS client for IPFire                                      #
   5 # Copyright (C) 2012 IPFire development team                                  #
   6 #                                                                             #
   7 # This program is free software: you can redistribute it and/or modify        #
   8 # it under the terms of the GNU General Public License as published by        #
   9 # the Free Software Foundation, either version 3 of the License, or           #
  10 # (at your option) any later version.                                         #
  11 #                                                                             #
  12 # This program is distributed in the hope that it will be useful,             #
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of              #
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               #
  15 # GNU General Public License for more details.                                #
  16 #                                                                             #
  17 # You should have received a copy of the GNU General Public License           #
  18 # along with this program.  If not, see <http://www.gnu.org/licenses/>.       #
  19 #                                                                             #
  20 ###############################################################################
  21
  22 import logging
  23 import urllib2
  24 import xml.dom.minidom
  25
  26 from i18n import _
  27
  28 # Import all possible exception types.
  29 from .errors import *
  30
  31 logger = logging.getLogger("ddns.providers")
  32 logger.propagate = 1
  33
  34 class DDNSProvider(object):
  35         # A short string that uniquely identifies
  36         # this provider.
  37         handle = None
  38
  39         # The full name of the provider.
  40         name = None
  41
  42         # A weburl to the homepage of the provider.
  43         # (Where to register a new account?)
  44         website = None
  45
  46         # A list of supported protocols.
  47         protocols = ("ipv6", "ipv4")
  48
  49         DEFAULT_SETTINGS = {}
  50
  51         def __init__(self, core, **settings):
  52                 self.core = core
  53
  54                 # Copy a set of default settings and
  55                 # update them by those from the configuration file.
  56                 self.settings = self.DEFAULT_SETTINGS.copy()
  57                 self.settings.update(settings)
  58
  59         def __repr__(self):
  60                 return "<DDNS Provider %s (%s)>" % (self.name, self.handle)
  61
  62         def __cmp__(self, other):
  63                 return cmp(self.hostname, other.hostname)
  64
  65         def get(self, key, default=None):
  66                 """
  67                         Get a setting from the settings dictionary.
  68                 """
  69                 return self.settings.get(key, default)
  70
  71         @property
  72         def hostname(self):
  73                 """
  74                         Fast access to the hostname.
  75                 """
  76                 return self.get("hostname")
  77
  78         @property
  79         def username(self):
  80                 """
  81                         Fast access to the username.
  82                 """
  83                 return self.get("username")
  84
  85         @property
  86         def password(self):
  87                 """
  88                         Fast access to the password.
  89                 """
  90                 return self.get("password")
  91
  92         @property
  93         def token(self):
  94                 """
  95                         Fast access to the token.
  96                 """
  97                 return self.get("token")
  98
  99         def __call__(self, force=False):
 100                 if force:
 101                         logger.debug(_("Updating %s forced") % self.hostname)
 102
 103                 # Check if we actually need to update this host.
 104                 elif self.is_uptodate(self.protocols):
 105                         logger.debug(_("%s is already up to date") % self.hostname)
 106                         return
 107
 108                 # Execute the update.
 109                 self.update()
 110
 111         def update(self):
 112                 raise NotImplementedError
 113
 114         def is_uptodate(self, protos):
 115                 """
 116                         Returns True if this host is already up to date
 117                         and does not need to change the IP address on the
 118                         name server.
 119                 """
 120                 for proto in protos:
 121                         addresses = self.core.system.resolve(self.hostname, proto)
 122
 123                         current_address = self.get_address(proto)
 124
 125                         # If no addresses for the given protocol exist, we
 126                         # are fine...
 127                         if current_address is None and not addresses:
 128                                 continue
 129
 130                         if not current_address in addresses:
 131                                 return False
 132
 133                 return True
 134
 135         def send_request(self, *args, **kwargs):
 136                 """
 137                         Proxy connection to the send request
 138                         method.
 139                 """
 140                 return self.core.system.send_request(*args, **kwargs)
 141
 142         def get_address(self, proto, default=None):
 143                 """
 144                         Proxy method to get the current IP address.
 145                 """
 146                 return self.core.system.get_address(proto) or default
 147
 148
 149 class DDNSProviderAllInkl(DDNSProvider):
 150         handle    = "all-inkl.com"
 151         name      = "All-inkl.com"
 152         website   = "http://all-inkl.com/"
 153         protocols = ("ipv4",)
 154
 155         # There are only information provided by the vendor how to
 156         # perform an update on a FRITZ Box. Grab requried informations
 157         # from the net.
 158         # http://all-inkl.goetze.it/v01/ddns-mit-einfachen-mitteln/
 159
 160         url = "http://dyndns.kasserver.com"
 161
 162         def update(self):
 163                 # There is no additional data required so we directly can
 164                 # send our request.
 165                 response = self.send_request(self.url, username=self.username, password=self.password)
 166
 167                 # Get the full response message.
 168                 output = response.read()
 169
 170                 # Handle success messages.
 171                 if output.startswith("good") or output.startswith("nochg"):
 172                         return
 173
 174                 # If we got here, some other update error happened.
 175                 raise DDNSUpdateError
 176
 177
 178 class DDNSProviderDHS(DDNSProvider):
 179         handle    = "dhs.org"
 180         name      = "DHS International"
 181         website   = "http://dhs.org/"
 182         protocols = ("ipv4",)
 183
 184         # No information about the used update api provided on webpage,
 185         # grabed from source code of ez-ipudate.
 186         url = "http://members.dhs.org/nic/hosts"
 187
 188         def update(self):
 189                 data = {
 190                         "domain"       : self.hostname,
 191                         "ip"           : self.get_address("ipv4"),
 192                         "hostcmd"      : "edit",
 193                         "hostcmdstage" : "2",
 194                         "type"         : "4",
 195                 }
 196
 197                 # Send update to the server.
 198                 response = self.send_request(self.url, username=self.username, password=self.password,
 199                         data=data)
 200
 201                 # Handle success messages.
 202                 if response.code == 200:
 203                         return
 204
 205                 # If we got here, some other update error happened.
 206                 raise DDNSUpdateError
 207
 208
 209 class DDNSProviderDNSpark(DDNSProvider):
 210         handle    = "dnspark.com"
 211         name      = "DNS Park"
 212         website   = "http://dnspark.com/"
 213         protocols = ("ipv4",)
 214
 215         # Informations to the used api can be found here:
 216         # https://dnspark.zendesk.com/entries/31229348-Dynamic-DNS-API-Documentation
 217         url = "https://control.dnspark.com/api/dynamic/update.php"
 218
 219         def update(self):
 220                 data = {
 221                         "domain" : self.hostname,
 222                         "ip"     : self.get_address("ipv4"),
 223                 }
 224
 225                 # Send update to the server.
 226                 response = self.send_request(self.url, username=self.username, password=self.password,
 227                         data=data)
 228
 229                 # Get the full response message.
 230                 output = response.read()
 231
 232                 # Handle success messages.
 233                 if output.startswith("ok") or output.startswith("nochange"):
 234                         return
 235
 236                 # Handle error codes.
 237                 if output == "unauth":
 238                         raise DDNSAuthenticationError
 239                 elif output == "abuse":
 240                         raise DDNSAbuseError
 241                 elif output == "blocked":
 242                         raise DDNSBlockedError
 243                 elif output == "nofqdn":
 244                         raise DDNSRequestError(_("No valid FQDN was given."))
 245                 elif output == "nohost":
 246                         raise DDNSRequestError(_("Invalid hostname specified."))
 247                 elif output == "notdyn":
 248                         raise DDNSRequestError(_("Hostname not marked as a dynamic host."))
 249                 elif output == "invalid":
 250                         raise DDNSRequestError(_("Invalid IP address has been sent."))
 251
 252                 # If we got here, some other update error happened.
 253                 raise DDNSUpdateError
 254
 255
 256 class DDNSProviderDtDNS(DDNSProvider):
 257         handle    = "dtdns.com"
 258         name      = "DtDNS"
 259         website   = "http://dtdns.com/"
 260         protocols = ("ipv4",)
 261
 262         # Information about the format of the HTTPS request is to be found
 263         # http://www.dtdns.com/dtsite/updatespec
 264         url = "https://www.dtdns.com/api/autodns.cfm"
 265
 266         def update(self):
 267                 data = {
 268                         "ip" : self.get_address("ipv4"),
 269                         "id" : self.hostname,
 270                         "pw" : self.password
 271                 }
 272
 273                 # Send update to the server.
 274                 response = self.send_request(self.url, data=data)
 275
 276                 # Get the full response message.
 277                 output = response.read()
 278
 279                 # Remove all leading and trailing whitespace.
 280                 output = output.strip()
 281
 282                 # Handle success messages.
 283                 if "now points to" in output:
 284                         return
 285
 286                 # Handle error codes.
 287                 if output == "No hostname to update was supplied.":
 288                         raise DDNSRequestError(_("No hostname specified."))
 289
 290                 elif output == "The hostname you supplied is not valid.":
 291                         raise DDNSRequestError(_("Invalid hostname specified."))
 292
 293                 elif output == "The password you supplied is not valid.":
 294                         raise DDNSAuthenticationError
 295
 296                 elif output == "Administration has disabled this account.":
 297                         raise DDNSRequestError(_("Account has been disabled."))
 298
 299                 elif output == "Illegal character in IP.":
 300                         raise DDNSRequestError(_("Invalid IP address has been sent."))
 301
 302                 elif output == "Too many failed requests.":
 303                         raise DDNSRequestError(_("Too many failed requests."))
 304
 305                 # If we got here, some other update error happened.
 306                 raise DDNSUpdateError
 307
 308
 309 class DDNSProviderDynDNS(DDNSProvider):
 310         handle    = "dyndns.org"
 311         name      = "Dyn"
 312         website   = "http://dyn.com/dns/"
 313         protocols = ("ipv4",)
 314
 315         # Information about the format of the request is to be found
 316         # http://http://dyn.com/support/developers/api/perform-update/
 317         # http://dyn.com/support/developers/api/return-codes/
 318         url = "https://members.dyndns.org/nic/update"
 319
 320         def _prepare_request_data(self):
 321                 data = {
 322                         "hostname" : self.hostname,
 323                         "myip"     : self.get_address("ipv4"),
 324                 }
 325
 326                 return data
 327
 328         def update(self):
 329                 data = self._prepare_request_data()
 330
 331                 # Send update to the server.
 332                 response = self.send_request(self.url, data=data,
 333                         username=self.username, password=self.password)
 334
 335                 # Get the full response message.
 336                 output = response.read()
 337
 338                 # Handle success messages.
 339                 if output.startswith("good") or output.startswith("nochg"):
 340                         return
 341
 342                 # Handle error codes.
 343                 if output == "badauth":
 344                         raise DDNSAuthenticationError
 345                 elif output == "aduse":
 346                         raise DDNSAbuseError
 347                 elif output == "notfqdn":
 348                         raise DDNSRequestError(_("No valid FQDN was given."))
 349                 elif output == "nohost":
 350                         raise DDNSRequestError(_("Specified host does not exist."))
 351                 elif output == "911":
 352                         raise DDNSInternalServerError
 353                 elif output == "dnserr":
 354                         raise DDNSInternalServerError(_("DNS error encountered."))
 355
 356                 # If we got here, some other update error happened.
 357                 raise DDNSUpdateError(_("Server response: %s") % output)
 358
 359
 360 class DDNSProviderDynU(DDNSProviderDynDNS):
 361         handle    = "dynu.com"
 362         name      = "Dynu"
 363         website   = "http://dynu.com/"
 364         protocols = ("ipv6", "ipv4",)
 365
 366         # Detailed information about the request and response codes
 367         # are available on the providers webpage.
 368         # http://dynu.com/Default.aspx?page=dnsapi
 369
 370         url = "https://api.dynu.com/nic/update"
 371
 372         def _prepare_request_data(self):
 373                 data = DDNSProviderDynDNS._prepare_request_data(self)
 374
 375                 # This one supports IPv6
 376                 data.update({
 377                         "myipv6"   : self.get_address("ipv6"),
 378                 })
 379
 380                 return data
 381
 382
 383 class DDNSProviderEasyDNS(DDNSProviderDynDNS):
 384         handle  = "easydns.com"
 385         name    = "EasyDNS"
 386         website = "http://www.easydns.com/"
 387
 388         # There is only some basic documentation provided by the vendor,
 389         # also searching the web gain very poor results.
 390         # http://mediawiki.easydns.com/index.php/Dynamic_DNS
 391
 392         url = "http://api.cp.easydns.com/dyn/tomato.php"
 393
 394
 395 class DDNSProviderFreeDNSAfraidOrg(DDNSProvider):
 396         handle    = "freedns.afraid.org"
 397         name      = "freedns.afraid.org"
 398         website   = "http://freedns.afraid.org/"
 399
 400         # No information about the request or response could be found on the vendor
 401         # page. All used values have been collected by testing.
 402         url = "https://freedns.afraid.org/dynamic/update.php"
 403
 404         @property
 405         def proto(self):
 406                 return self.get("proto")
 407
 408         def update(self):
 409                 address = self.get_address(self.proto)
 410
 411                 data = {
 412                         "address" : address,
 413                 }
 414
 415                 # Add auth token to the update url.
 416                 url = "%s?%s" % (self.url, self.token)
 417
 418                 # Send update to the server.
 419                 response = self.send_request(url, data=data)
 420
 421                 if output.startswith("Updated") or "has not changed" in output:
 422                         return
 423
 424                 # Handle error codes.
 425                 if output == "ERROR: Unable to locate this record":
 426                         raise DDNSAuthenticationError
 427                 elif "is an invalid IP address" in output:
 428                         raise DDNSRequestError(_("Invalid IP address has been sent."))
 429
 430
 431 class DDNSProviderLightningWireLabs(DDNSProvider):
 432         handle    = "dns.lightningwirelabs.com"
 433         name      = "Lightning Wire Labs DNS Service"
 434         website   = "http://dns.lightningwirelabs.com/"
 435
 436         # Information about the format of the HTTPS request is to be found
 437         # https://dns.lightningwirelabs.com/knowledge-base/api/ddns
 438         url = "https://dns.lightningwirelabs.com/update"
 439
 440         def update(self):
 441                 data =  {
 442                         "hostname" : self.hostname,
 443                         "address6" : self.get_address("ipv6", "-"),
 444                         "address4" : self.get_address("ipv4", "-"),
 445                 }
 446
 447                 # Check if a token has been set.
 448                 if self.token:
 449                         data["token"] = self.token
 450
 451                 # Check for username and password.
 452                 elif self.username and self.password:
 453                         data.update({
 454                                 "username" : self.username,
 455                                 "password" : self.password,
 456                         })
 457
 458                 # Raise an error if no auth details are given.
 459                 else:
 460                         raise DDNSConfigurationError
 461
 462                 # Send update to the server.
 463                 response = self.send_request(self.url, data=data)
 464
 465                 # Handle success messages.
 466                 if response.code == 200:
 467                         return
 468
 469                 # If we got here, some other update error happened.
 470                 raise DDNSUpdateError
 471
 472
 473 class DDNSProviderNamecheap(DDNSProvider):
 474         handle    = "namecheap.com"
 475         name      = "Namecheap"
 476         website   = "http://namecheap.com"
 477         protocols = ("ipv4",)
 478
 479         # Information about the format of the HTTP request is to be found
 480         # https://www.namecheap.com/support/knowledgebase/article.aspx/9249/0/nc-dynamic-dns-to-dyndns-adapter
 481         # https://community.namecheap.com/forums/viewtopic.php?f=6&t=6772
 482
 483         url = "https://dynamicdns.park-your-domain.com/update"
 484
 485         def parse_xml(self, document, content):
 486                 # Send input to the parser.
 487                 xmldoc = xml.dom.minidom.parseString(document)
 488
 489                 # Get XML elements by the given content.
 490                 element = xmldoc.getElementsByTagName(content)
 491
 492                 # If no element has been found, we directly can return None.
 493                 if not element:
 494                         return None
 495
 496                 # Only get the first child from an element, even there are more than one.
 497                 firstchild = element[0].firstChild
 498
 499                 # Get the value of the child.
 500                 value = firstchild.nodeValue
 501
 502                 # Return the value.
 503                 return value
 504
 505         def update(self):
 506                 # Namecheap requires the hostname splitted into a host and domain part.
 507                 host, domain = self.hostname.split(".", 1)
 508
 509                 data = {
 510                         "ip"       : self.get_address("ipv4"),
 511                         "password" : self.password,
 512                         "host"     : host,
 513                         "domain"   : domain
 514                 }
 515
 516                 # Send update to the server.
 517                 response = self.send_request(self.url, data=data)
 518
 519                 # Get the full response message.
 520                 output = response.read()
 521
 522                 # Handle success messages.
 523                 if self.parse_xml(output, "IP") == self.get_address("ipv4"):
 524                         return
 525
 526                 # Handle error codes.
 527                 errorcode = self.parse_xml(output, "ResponseNumber")
 528
 529                 if errorcode == "304156":
 530                         raise DDNSAuthenticationError
 531                 elif errorcode == "316153":
 532                         raise DDNSRequestError(_("Domain not found."))
 533                 elif errorcode == "316154":
 534                         raise DDNSRequestError(_("Domain not active."))
 535                 elif errorcode in ("380098", "380099"):
 536                         raise DDNSInternalServerError
 537
 538                 # If we got here, some other update error happened.
 539                 raise DDNSUpdateError
 540
 541
 542 class DDNSProviderNOIP(DDNSProviderDynDNS):
 543         handle  = "no-ip.com"
 544         name    = "No-IP"
 545         website = "http://www.no-ip.com/"
 546
 547         # Information about the format of the HTTP request is to be found
 548         # here: http://www.no-ip.com/integrate/request and
 549         # here: http://www.no-ip.com/integrate/response
 550
 551         url = "http://dynupdate.no-ip.com/nic/update"
 552
 553         def _prepare_request_data(self):
 554                 data = {
 555                         "hostname" : self.hostname,
 556                         "address"  : self.get_address("ipv4"),
 557                 }
 558
 559                 return data
 560
 561
 562 class DDNSProviderOVH(DDNSProviderDynDNS):
 563         handle  = "ovh.com"
 564         name    = "OVH"
 565         website = "http://www.ovh.com/"
 566
 567         # OVH only provides very limited information about how to
 568         # update a DynDNS host. They only provide the update url
 569         # on the their german subpage.
 570         #
 571         # http://hilfe.ovh.de/DomainDynHost
 572
 573         url = "https://www.ovh.com/nic/update"
 574
 575         def _prepare_request_data(self):
 576                 data = DDNSProviderDynDNS._prepare_request_data(self)
 577                 data.update({
 578                         "system" : "dyndns",
 579                 })
 580
 581                 return data
 582
 583
 584 class DDNSProviderRegfish(DDNSProvider):
 585         handle  = "regfish.com"
 586         name    = "Regfish GmbH"
 587         website = "http://www.regfish.com/"
 588
 589         # A full documentation to the providers api can be found here
 590         # but is only available in german.
 591         # https://www.regfish.de/domains/dyndns/dokumentation
 592
 593         url = "https://dyndns.regfish.de/"
 594
 595         def update(self):
 596                 data = {
 597                         "fqdn" : self.hostname,
 598                 }
 599
 600                 # Check if we update an IPv6 address.
 601                 address6 = self.get_address("ipv6")
 602                 if address6:
 603                         data["ipv6"] = address6
 604
 605                 # Check if we update an IPv4 address.
 606                 address4 = self.get_address("ipv4")
 607                 if address4:
 608                         data["ipv4"] = address4
 609
 610                 # Raise an error if none address is given.
 611                 if not data.has_key("ipv6") and not data.has_key("ipv4"):
 612                         raise DDNSConfigurationError
 613
 614                 # Check if a token has been set.
 615                 if self.token:
 616                         data["token"] = self.token
 617
 618                 # Raise an error if no token and no useranem and password
 619                 # are given.
 620                 elif not self.username and not self.password:
 621                         raise DDNSConfigurationError(_("No Auth details specified."))
 622
 623                 # HTTP Basic Auth is only allowed if no token is used.
 624                 if self.token:
 625                         # Send update to the server.
 626                         response = self.send_request(self.url, data=data)
 627                 else:
 628                         # Send update to the server.
 629                         response = self.send_request(self.url, username=self.username, password=self.password,
 630                                 data=data)
 631
 632                 # Get the full response message.
 633                 output = response.read()
 634
 635                 # Handle success messages.
 636                 if "100" in output or "101" in output:
 637                         return
 638
 639                 # Handle error codes.
 640                 if "401" or "402" in output:
 641                         raise DDNSAuthenticationError
 642                 elif "408" in output:
 643                         raise DDNSRequestError(_("Invalid IPv4 address has been sent."))
 644                 elif "409" in output:
 645                         raise DDNSRequestError(_("Invalid IPv6 address has been sent."))
 646                 elif "412" in output:
 647                         raise DDNSRequestError(_("No valid FQDN was given."))
 648                 elif "414" in output:
 649                         raise DDNSInternalServerError
 650
 651                 # If we got here, some other update error happened.
 652                 raise DDNSUpdateError
 653
 654
 655 class DDNSProviderSelfhost(DDNSProviderDynDNS):
 656         handle    = "selfhost.de"
 657         name      = "Selfhost.de"
 658         website   = "http://www.selfhost.de/"
 659
 660         url = "https://carol.selfhost.de/nic/update"
 661
 662         def _prepare_request_data(self):
 663                 data = DDNSProviderDynDNS._prepare_request_data(self)
 664                 data.update({
 665                         "hostname" : "1",
 666                 })
 667
 668                 return data
 669
 670
 671 class DDNSProviderSPDNS(DDNSProviderDynDNS):
 672         handle  = "spdns.org"
 673         name    = "SPDNS"
 674         website = "http://spdns.org/"
 675
 676         # Detailed information about request and response codes are provided
 677         # by the vendor. They are using almost the same mechanism and status
 678         # codes as dyndns.org so we can inherit all those stuff.
 679         #
 680         # http://wiki.securepoint.de/index.php/SPDNS_FAQ
 681         # http://wiki.securepoint.de/index.php/SPDNS_Update-Tokens
 682
 683         url = "https://update.spdns.de/nic/update"
 684
 685
 686 class DDNSProviderStrato(DDNSProviderDynDNS):
 687         handle  = "strato.com"
 688         name    = "Strato AG"
 689         website = "http:/www.strato.com/"
 690
 691         # Information about the request and response can be obtained here:
 692         # http://www.strato-faq.de/article/671/So-einfach-richten-Sie-DynDNS-f%C3%BCr-Ihre-Domains-ein.html
 693
 694         url = "https://dyndns.strato.com/nic/update"
 695
 696
 697 class DDNSProviderTwoDNS(DDNSProviderDynDNS):
 698         handle  = "twodns.de"
 699         name    = "TwoDNS"
 700         website = "http://www.twodns.de"
 701
 702         # Detailed information about the request can be found here
 703         # http://twodns.de/en/faqs
 704         # http://twodns.de/en/api
 705
 706         url = "https://update.twodns.de/update"
 707
 708         def _prepare_request_data(self):
 709                 data = {
 710                         "ip" : self.get_address("ipv4"),
 711                         "hostname" : self.hostname
 712                 }
 713
 714                 return data
 715
 716
 717 class DDNSProviderUdmedia(DDNSProviderDynDNS):
 718         handle  = "udmedia.de"
 719         name    = "Udmedia GmbH"
 720         website = "http://www.udmedia.de"
 721
 722         # Information about the request can be found here
 723         # http://www.udmedia.de/faq/content/47/288/de/wie-lege-ich-einen-dyndns_eintrag-an.html
 724
 725         url = "https://www.udmedia.de/nic/update"
 726
 727
 728 class DDNSProviderVariomedia(DDNSProviderDynDNS):
 729         handle    = "variomedia.de"
 730         name      = "Variomedia"
 731         website   = "http://www.variomedia.de/"
 732         protocols = ("ipv6", "ipv4",)
 733
 734         # Detailed information about the request can be found here
 735         # https://dyndns.variomedia.de/
 736
 737         url = "https://dyndns.variomedia.de/nic/update"
 738
 739         @property
 740         def proto(self):
 741                 return self.get("proto")
 742
 743         def _prepare_request_data(self):
 744                 data = {
 745                         "hostname" : self.hostname,
 746                         "myip"     : self.get_address(self.proto)
 747                 }
 748
 749                 return data
 750
 751
 752 class DDNSProviderZoneedit(DDNSProvider):
 753         handle  = "zoneedit.com"
 754         name    = "Zoneedit"
 755         website = "http://www.zoneedit.com"
 756
 757         # Detailed information about the request and the response codes can be
 758         # obtained here:
 759         # http://www.zoneedit.com/doc/api/other.html
 760         # http://www.zoneedit.com/faq.html
 761
 762         url = "https://dynamic.zoneedit.com/auth/dynamic.html"
 763
 764         @property
 765         def proto(self):
 766                 return self.get("proto")
 767
 768         def update(self):
 769                 data = {
 770                         "dnsto" : self.get_address(self.proto),
 771                         "host"  : self.hostname
 772                 }
 773
 774                 # Send update to the server.
 775                 response = self.send_request(self.url, username=self.username, password=self.password,
 776                         data=data)
 777
 778                 # Get the full response message.
 779                 output = response.read()
 780
 781                 # Handle success messages.
 782                 if output.startswith("<SUCCESS"):
 783                         return
 784
 785                 # Handle error codes.
 786                 if output.startswith("invalid login"):
 787                         raise DDNSAuthenticationError
 788                 elif output.startswith("<ERROR CODE=\"704\""):
 789                         raise DDNSRequestError(_("No valid FQDN was given."))
 790                 elif output.startswith("<ERROR CODE=\"702\""):
 791                         raise DDNSInternalServerError
 792
 793                 # If we got here, some other update error happened.
 794                 raise DDNSUpdateError