source4/scripting/bin/samba_dnsupdate

   1 #!/usr/bin/env python
   2 # vim: expandtab
   3 #
   4 # update our DNS names using TSIG-GSS
   5 #
   6 # Copyright (C) Andrew Tridgell 2010
   7 #
   8 # This program is free software; you can redistribute it and/or modify
   9 # it under the terms of the GNU General Public License as published by
  10 # the Free Software Foundation; either version 3 of the License, or
  11 # (at your option) any later version.
  12 #
  13 # This program is distributed in the hope that it will be useful,
  14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 # GNU General Public License for more details.
  17 #
  18 # You should have received a copy of the GNU General Public License
  19 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21
  22 import os
  23 import fcntl
  24 import sys
  25 import tempfile
  26 import subprocess
  27
  28 # ensure we get messages out immediately, so they get in the samba logs,
  29 # and don't get swallowed by a timeout
  30 os.environ['PYTHONUNBUFFERED'] = '1'
  31
  32 # forcing GMT avoids a problem in some timezones with kerberos. Both MIT
  33 # heimdal can get mutual authentication errors due to the 24 second difference
  34 # between UTC and GMT when using some zone files (eg. the PDT zone from
  35 # the US)
  36 os.environ["TZ"] = "GMT"
  37
  38 # Find right directory when running from source tree
  39 sys.path.insert(0, "bin/python")
  40
  41 import samba
  42 import optparse
  43 from samba import getopt as options
  44 from ldb import SCOPE_BASE
  45 from samba import dsdb
  46 from samba.auth import system_session
  47 from samba.samdb import SamDB
  48 from samba.dcerpc import netlogon, winbind
  49 from samba.netcmd.dns import cmd_dns
  50 from samba import gensec
  51 from samba.kcc import kcc_utils
  52 from samba.compat import get_string
  53 from samba.compat import text_type
  54 import ldb
  55
  56 import dns.resolver
  57 import dns.exception
  58
  59 default_ttl = 900
  60 am_rodc = False
  61 error_count = 0
  62
  63 parser = optparse.OptionParser("samba_dnsupdate")
  64 sambaopts = options.SambaOptions(parser)
  65 parser.add_option_group(sambaopts)
  66 parser.add_option_group(options.VersionOptions(parser))
  67 parser.add_option("--verbose", action="store_true")
  68 parser.add_option("--use-samba-tool", action="store_true", help="Use samba-tool to make updates over RPC, rather than over DNS")
  69 parser.add_option("--use-nsupdate", action="store_true", help="Use nsupdate command to make updates over DNS (default, if kinit successful)")
  70 parser.add_option("--all-names", action="store_true")
  71 parser.add_option("--all-interfaces", action="store_true")
  72 parser.add_option("--current-ip", action="append", help="IP address to update DNS to match (helpful if behind NAT, valid multiple times, defaults to values from interfaces=)")
  73 parser.add_option("--rpc-server-ip", type="string", help="IP address of server to use with samba-tool (defaults to first --current-ip)")
  74 parser.add_option("--use-file", type="string", help="Use a file, rather than real DNS calls")
  75 parser.add_option("--update-list", type="string", help="Add DNS names from the given file")
  76 parser.add_option("--update-cache", type="string", help="Cache database of already registered records")
  77 parser.add_option("--fail-immediately", action='store_true', help="Exit on first failure")
  78 parser.add_option("--no-credentials", dest='nocreds', action='store_true', help="don't try and get credentials")
  79 parser.add_option("--no-substitutions", dest='nosubs', action='store_true', help="don't try and expands variables in file specified by --update-list")
  80
  81 creds = None
  82 ccachename = None
  83
  84 opts, args = parser.parse_args()
  85
  86 if len(args) != 0:
  87     parser.print_usage()
  88     sys.exit(1)
  89
  90 lp = sambaopts.get_loadparm()
  91
  92 domain = lp.get("realm")
  93 host = lp.get("netbios name")
  94 if opts.all_interfaces:
  95     all_interfaces = True
  96 else:
  97     all_interfaces = False
  98
  99 if opts.current_ip:
 100     IPs = opts.current_ip
 101 else:
 102     IPs = samba.interface_ips(lp, all_interfaces)
 103
 104 nsupdate_cmd = lp.get('nsupdate command')
 105 dns_zone_scavenging = lp.get("dns zone scavenging")
 106
 107 if len(IPs) == 0:
 108     print("No IP interfaces - skipping DNS updates")
 109     sys.exit(0)
 110
 111 if opts.rpc_server_ip:
 112     rpc_server_ip = opts.rpc_server_ip
 113 else:
 114     rpc_server_ip = IPs[0]
 115
 116 IP6s = []
 117 IP4s = []
 118 for i in IPs:
 119     if i.find(':') != -1:
 120         IP6s.append(i)
 121     else:
 122         IP4s.append(i)
 123
 124 smb_conf = sambaopts.get_loadparm_path()
 125
 126 if opts.verbose:
 127     print("IPs: %s" % IPs)
 128
 129 def get_possible_rw_dns_server(creds, domain):
 130     """Get a list of possible read-write DNS servers, starting with
 131        the SOA.  The SOA is the correct answer, but old Samba domains
 132        (4.6 and prior) do not maintain this value, so add NS servers
 133        as well"""
 134
 135     hostnames = []
 136     ans_soa = check_one_dns_name(domain, 'SOA')
 137
 138     # Actually there is only one
 139     for i in range(len(ans_soa)):
 140         hostnames.append(str(ans_soa[i].mname).rstrip('.'))
 141
 142     # This is not strictly legit, but old Samba domains may have an
 143     # unmaintained SOA record, so go for any NS that we can get a
 144     # ticket to.
 145     ans_ns = check_one_dns_name(domain, 'NS')
 146
 147     # Actually there is only one
 148     for i in range(len(ans_ns)):
 149         hostnames.append(str(ans_ns[i].target).rstrip('.'))
 150
 151     return hostnames
 152
 153 def get_krb5_rw_dns_server(creds, domain):
 154     """Get a list of read-write DNS servers that we can obtain a ticket
 155        for, starting with the SOA.  The SOA is the correct answer, but
 156        old Samba domains (4.6 and prior) do not maintain this value,
 157        so continue with the NS servers as well until we get one that
 158        the KDC will issue a ticket to.
 159     """
 160
 161     rw_dns_servers = get_possible_rw_dns_server(creds, domain)
 162     # Actually there is only one
 163     for i in range(len(rw_dns_servers)):
 164         target_hostname = str(rw_dns_servers[i])
 165         settings = {}
 166         settings["lp_ctx"] = lp
 167         settings["target_hostname"] = target_hostname
 168
 169         gensec_client = gensec.Security.start_client(settings)
 170         gensec_client.set_credentials(creds)
 171         gensec_client.set_target_service("DNS")
 172         gensec_client.set_target_hostname(target_hostname)
 173         gensec_client.want_feature(gensec.FEATURE_SEAL)
 174         gensec_client.start_mech_by_sasl_name("GSSAPI")
 175         server_to_client = b""
 176         try:
 177             (client_finished, client_to_server) = gensec_client.update(server_to_client)
 178             if opts.verbose:
 179                 print("Successfully obtained Kerberos ticket to DNS/%s as %s" \
 180                     % (target_hostname, creds.get_username()))
 181             return target_hostname
 182         except RuntimeError:
 183             # Only raise an exception if they all failed
 184             if i != len(rw_dns_servers) - 1:
 185                 pass
 186             raise
 187
 188 def get_credentials(lp):
 189     """# get credentials if we haven't got them already."""
 190     from samba import credentials
 191     global ccachename
 192     creds = credentials.Credentials()
 193     creds.guess(lp)
 194     creds.set_machine_account(lp)
 195     creds.set_krb_forwardable(credentials.NO_KRB_FORWARDABLE)
 196     (tmp_fd, ccachename) = tempfile.mkstemp()
 197     try:
 198         if opts.use_file is not None:
 199             return
 200
 201         creds.get_named_ccache(lp, ccachename)
 202
 203         # Now confirm we can get a ticket to the DNS server
 204         get_krb5_rw_dns_server(creds, sub_vars['DNSDOMAIN'] + '.')
 205         return creds
 206
 207     except RuntimeError as e:
 208         os.unlink(ccachename)
 209         raise e
 210
 211
 212 class dnsobj(object):
 213     """an object to hold a parsed DNS line"""
 214
 215     def __init__(self, string_form):
 216         list = string_form.split()
 217         if len(list) < 3:
 218             raise Exception("Invalid DNS entry %r" % string_form)
 219         self.dest = None
 220         self.port = None
 221         self.ip = None
 222         self.existing_port = None
 223         self.existing_weight = None
 224         self.existing_cname_target = None
 225         self.rpc = False
 226         self.zone = None
 227         if list[0] == "RPC":
 228             self.rpc = True
 229             self.zone = list[1]
 230             list = list[2:]
 231         self.type = list[0]
 232         self.name = list[1]
 233         self.nameservers = []
 234         if self.type == 'SRV':
 235             if len(list) < 4:
 236                 raise Exception("Invalid DNS entry %r" % string_form)
 237             self.dest = list[2]
 238             self.port = list[3]
 239         elif self.type in ['A', 'AAAA']:
 240             self.ip   = list[2] # usually $IP, which gets replaced
 241         elif self.type == 'CNAME':
 242             self.dest = list[2]
 243         elif self.type == 'NS':
 244             self.dest = list[2]
 245         else:
 246             raise Exception("Received unexpected DNS reply of type %s: %s" % (self.type, string_form))
 247
 248     def __str__(self):
 249         if self.type == "A":
 250             return "%s %s %s" % (self.type, self.name, self.ip)
 251         if self.type == "AAAA":
 252             return "%s %s %s" % (self.type, self.name, self.ip)
 253         if self.type == "SRV":
 254             return "%s %s %s %s" % (self.type, self.name, self.dest, self.port)
 255         if self.type == "CNAME":
 256             return "%s %s %s" % (self.type, self.name, self.dest)
 257         if self.type == "NS":
 258             return "%s %s %s" % (self.type, self.name, self.dest)
 259
 260
 261 def parse_dns_line(line, sub_vars):
 262     """parse a DNS line from."""
 263     if line.startswith("SRV _ldap._tcp.pdc._msdcs.") and not samdb.am_pdc():
 264         # We keep this as compat to the dns_update_list of 4.0/4.1
 265         if opts.verbose:
 266             print("Skipping PDC entry (%s) as we are not a PDC" % line)
 267         return None
 268     subline = samba.substitute_var(line, sub_vars)
 269     if subline == '' or subline[0] == "#":
 270         return None
 271     return dnsobj(subline)
 272
 273
 274 def hostname_match(h1, h2):
 275     """see if two hostnames match."""
 276     h1 = str(h1)
 277     h2 = str(h2)
 278     return h1.lower().rstrip('.') == h2.lower().rstrip('.')
 279
 280 def get_resolver(d=None):
 281     resolv_conf = os.getenv('RESOLV_CONF')
 282     if not resolv_conf:
 283         resolv_conf = '/etc/resolv.conf'
 284     resolver = dns.resolver.Resolver(filename=resolv_conf, configure=True)
 285
 286     if d is not None and d.nameservers != []:
 287         resolver.nameservers = d.nameservers
 288
 289     return resolver
 290
 291 def check_one_dns_name(name, name_type, d=None):
 292     resolver = get_resolver(d)
 293     if d is not None and len(d.nameservers) == 0:
 294         d.nameservers = resolver.nameservers
 295
 296     ans = resolver.query(name, name_type)
 297     return ans
 298
 299 def check_dns_name(d):
 300     """check that a DNS entry exists."""
 301     normalised_name = d.name.rstrip('.') + '.'
 302     if opts.verbose:
 303         print("Looking for DNS entry %s as %s" % (d, normalised_name))
 304
 305     if opts.use_file is not None:
 306         try:
 307             dns_file = open(opts.use_file, "r")
 308         except IOError:
 309             return False
 310
 311         for line in dns_file:
 312             line = line.strip()
 313             if line == '' or line[0] == "#":
 314                 continue
 315             if line.lower() == str(d).lower():
 316                 return True
 317         return False
 318
 319     try:
 320         ans = check_one_dns_name(normalised_name, d.type, d)
 321     except dns.exception.Timeout:
 322         raise Exception("Timeout while waiting to contact a working DNS server while looking for %s as %s" % (d, normalised_name))
 323     except dns.resolver.NoNameservers:
 324         raise Exception("Unable to contact a working DNS server while looking for %s as %s" % (d, normalised_name))
 325     except dns.resolver.NXDOMAIN:
 326         if opts.verbose:
 327             print("The DNS entry %s, queried as %s does not exist" % (d, normalised_name))
 328         return False
 329     except dns.resolver.NoAnswer:
 330         if opts.verbose:
 331             print("The DNS entry %s, queried as %s does not hold this record type" % (d, normalised_name))
 332         return False
 333     except dns.exception.DNSException:
 334         raise Exception("Failure while trying to resolve %s as %s" % (d, normalised_name))
 335     if d.type in ['A', 'AAAA']:
 336         # we need to be sure that our IP is there
 337         for rdata in ans:
 338             if str(rdata) == str(d.ip):
 339                 return True
 340     elif d.type == 'CNAME':
 341         for i in range(len(ans)):
 342             if hostname_match(ans[i].target, d.dest):
 343                 return True
 344             else:
 345                 d.existing_cname_target = str(ans[i].target)
 346     elif d.type == 'NS':
 347         for i in range(len(ans)):
 348             if hostname_match(ans[i].target, d.dest):
 349                 return True
 350     elif d.type == 'SRV':
 351         for rdata in ans:
 352             if opts.verbose:
 353                 print("Checking %s against %s" % (rdata, d))
 354             if hostname_match(rdata.target, d.dest):
 355                 if str(rdata.port) == str(d.port):
 356                     return True
 357                 else:
 358                     d.existing_port     = str(rdata.port)
 359                     d.existing_weight = str(rdata.weight)
 360
 361     if opts.verbose:
 362         print("Lookup of %s succeeded, but we failed to find a matching DNS entry for %s" % (normalised_name, d))
 363
 364     return False
 365
 366
 367 def get_subst_vars(samdb):
 368     """get the list of substitution vars."""
 369     global lp, am_rodc
 370     vars = {}
 371
 372     vars['DNSDOMAIN'] = samdb.domain_dns_name()
 373     vars['DNSFOREST'] = samdb.forest_dns_name()
 374     vars['HOSTNAME']  = samdb.host_dns_name()
 375     vars['NTDSGUID']  = samdb.get_ntds_GUID()
 376     vars['SITE']      = samdb.server_site_name()
 377     res = samdb.search(base=samdb.get_default_basedn(), scope=SCOPE_BASE, attrs=["objectGUID"])
 378     guid = samdb.schema_format_value("objectGUID", res[0]['objectGUID'][0])
 379     vars['DOMAINGUID'] = get_string(guid)
 380
 381     vars['IF_DC'] = ""
 382     vars['IF_RWDC'] = "# "
 383     vars['IF_RODC'] = "# "
 384     vars['IF_PDC'] = "# "
 385     vars['IF_GC'] = "# "
 386     vars['IF_RWGC'] = "# "
 387     vars['IF_ROGC'] = "# "
 388     vars['IF_DNS_DOMAIN'] = "# "
 389     vars['IF_RWDNS_DOMAIN'] = "# "
 390     vars['IF_RODNS_DOMAIN'] = "# "
 391     vars['IF_DNS_FOREST'] = "# "
 392     vars['IF_RWDNS_FOREST'] = "# "
 393     vars['IF_R0DNS_FOREST'] = "# "
 394
 395     am_rodc = samdb.am_rodc()
 396     if am_rodc:
 397         vars['IF_RODC'] = ""
 398     else:
 399         vars['IF_RWDC'] = ""
 400
 401     if samdb.am_pdc():
 402         vars['IF_PDC'] = ""
 403
 404     # check if we "are DNS server"
 405     res = samdb.search(base=samdb.get_config_basedn(),
 406                    expression='(objectguid=%s)' % vars['NTDSGUID'],
 407                    attrs=["options", "msDS-hasMasterNCs"])
 408
 409     if len(res) == 1:
 410         if "options" in res[0]:
 411             options = int(res[0]["options"][0])
 412             if (options & dsdb.DS_NTDSDSA_OPT_IS_GC) != 0:
 413                 vars['IF_GC'] = ""
 414                 if am_rodc:
 415                     vars['IF_ROGC'] = ""
 416                 else:
 417                     vars['IF_RWGC'] = ""
 418
 419         basedn = str(samdb.get_default_basedn())
 420         forestdn = str(samdb.get_root_basedn())
 421
 422         if "msDS-hasMasterNCs" in res[0]:
 423             for e in res[0]["msDS-hasMasterNCs"]:
 424                 if str(e) == "DC=DomainDnsZones,%s" % basedn:
 425                     vars['IF_DNS_DOMAIN'] = ""
 426                     if am_rodc:
 427                         vars['IF_RODNS_DOMAIN'] = ""
 428                     else:
 429                         vars['IF_RWDNS_DOMAIN'] = ""
 430                 if str(e) == "DC=ForestDnsZones,%s" % forestdn:
 431                     vars['IF_DNS_FOREST'] = ""
 432                     if am_rodc:
 433                         vars['IF_RODNS_FOREST'] = ""
 434                     else:
 435                         vars['IF_RWDNS_FOREST'] = ""
 436
 437     return vars
 438
 439
 440 def call_nsupdate(d, op="add"):
 441     """call nsupdate for an entry."""
 442     global ccachename, nsupdate_cmd, krb5conf
 443
 444     assert(op in ["add", "delete"])
 445
 446     if opts.verbose:
 447         print("Calling nsupdate for %s (%s)" % (d, op))
 448
 449     if opts.use_file is not None:
 450         try:
 451             rfile = open(opts.use_file, 'r+')
 452         except IOError:
 453             # Perhaps create it
 454             rfile = open(opts.use_file, 'w+')
 455             # Open it for reading again, in case someone else got to it first
 456             rfile = open(opts.use_file, 'r+')
 457         fcntl.lockf(rfile, fcntl.LOCK_EX)
 458         (file_dir, file_name) = os.path.split(opts.use_file)
 459         (tmp_fd, tmpfile) = tempfile.mkstemp(dir=file_dir, prefix=file_name, suffix="XXXXXX")
 460         wfile = os.fdopen(tmp_fd, 'a')
 461         rfile.seek(0)
 462         for line in rfile:
 463             if op == "delete":
 464                 l = parse_dns_line(line, {})
 465                 if str(l).lower() == str(d).lower():
 466                     continue
 467             wfile.write(line)
 468         if op == "add":
 469             wfile.write(str(d)+"\n")
 470         os.rename(tmpfile, opts.use_file)
 471         fcntl.lockf(rfile, fcntl.LOCK_UN)
 472         return
 473
 474     normalised_name = d.name.rstrip('.') + '.'
 475
 476     (tmp_fd, tmpfile) = tempfile.mkstemp()
 477     f = os.fdopen(tmp_fd, 'w')
 478
 479     # Getting this line right is really important.  When we are under
 480     # resolv_wrapper, then we want to use RESOLV_CONF and the
 481     # nameserver therein. The issue is that this parameter forces us
 482     # to only ever use that server, and not some other server that the
 483     # NS record may point to, even as we get a ticket to that other
 484     # server.
 485     #
 486     # Therefore we must not set this in production, instead we want
 487     # to find the name of a SOA for the zone and use that server.
 488
 489     if os.getenv('RESOLV_CONF') and d.nameservers != []:
 490         f.write('server %s\n' % d.nameservers[0])
 491     else:
 492         resolver = get_resolver(d)
 493
 494         # Local the zone for this name
 495         zone = dns.resolver.zone_for_name(normalised_name,
 496                                           resolver=resolver)
 497
 498         # Now find the SOA, or if we can't get a ticket to the SOA,
 499         # any server with an NS record we can get a ticket for.
 500         #
 501         # Thanks to the Kerberos Credentials cache this is not
 502         # expensive inside the loop
 503         server = get_krb5_rw_dns_server(creds, zone)
 504         f.write('server %s\n' % server)
 505
 506     if d.type == "A":
 507         f.write("update %s %s %u A %s\n" % (op, normalised_name, default_ttl, d.ip))
 508     if d.type == "AAAA":
 509         f.write("update %s %s %u AAAA %s\n" % (op, normalised_name, default_ttl, d.ip))
 510     if d.type == "SRV":
 511         if op == "add" and d.existing_port is not None:
 512             f.write("update delete %s SRV 0 %s %s %s\n" % (normalised_name, d.existing_weight,
 513                                                            d.existing_port, d.dest))
 514         f.write("update %s %s %u SRV 0 100 %s %s\n" % (op, normalised_name, default_ttl, d.port, d.dest))
 515     if d.type == "CNAME":
 516         f.write("update %s %s %u CNAME %s\n" % (op, normalised_name, default_ttl, d.dest))
 517     if d.type == "NS":
 518         f.write("update %s %s %u NS %s\n" % (op, normalised_name, default_ttl, d.dest))
 519     if opts.verbose:
 520         f.write("show\n")
 521     f.write("send\n")
 522     f.close()
 523
 524     # Set a bigger MTU size to work around a bug in nsupdate's doio_send()
 525     os.environ["SOCKET_WRAPPER_MTU"] = "2000"
 526
 527     global error_count
 528     if ccachename:
 529         os.environ["KRB5CCNAME"] = ccachename
 530     try:
 531         cmd = nsupdate_cmd[:]
 532         cmd.append(tmpfile)
 533         env = os.environ
 534         if krb5conf:
 535             env["KRB5_CONFIG"] = krb5conf
 536         if ccachename:
 537             env["KRB5CCNAME"] = ccachename
 538         ret = subprocess.call(cmd, shell=False, env=env)
 539         if ret != 0:
 540             if opts.fail_immediately:
 541                 if opts.verbose:
 542                     print("Failed update with %s" % tmpfile)
 543                 sys.exit(1)
 544             error_count = error_count + 1
 545             if opts.verbose:
 546                 print("Failed nsupdate: %d" % ret)
 547     except Exception as estr:
 548         if opts.fail_immediately:
 549             sys.exit(1)
 550         error_count = error_count + 1
 551         if opts.verbose:
 552             print("Failed nsupdate: %s : %s" % (str(d), estr))
 553     os.unlink(tmpfile)
 554
 555     # Let socket_wrapper set the default MTU size
 556     os.environ["SOCKET_WRAPPER_MTU"] = "0"
 557
 558
 559 def call_samba_tool(d, op="add", zone=None):
 560     """call samba-tool dns to update an entry."""
 561
 562     assert(op in ["add", "delete"])
 563
 564     if (sub_vars['DNSFOREST'] != sub_vars['DNSDOMAIN']) and \
 565        sub_vars['DNSFOREST'].endswith('.' + sub_vars['DNSDOMAIN']):
 566         print("Refusing to use samba-tool when forest %s is under domain %s" \
 567             % (sub_vars['DNSFOREST'], sub_vars['DNSDOMAIN']))
 568
 569     if opts.verbose:
 570         print("Calling samba-tool dns for %s (%s)" % (d, op))
 571
 572     normalised_name = d.name.rstrip('.') + '.'
 573     if zone is None:
 574         if normalised_name == (sub_vars['DNSDOMAIN'] + '.'):
 575             short_name = '@'
 576             zone = sub_vars['DNSDOMAIN']
 577         elif normalised_name == (sub_vars['DNSFOREST'] + '.'):
 578             short_name = '@'
 579             zone = sub_vars['DNSFOREST']
 580         elif normalised_name == ('_msdcs.' + sub_vars['DNSFOREST'] + '.'):
 581             short_name = '@'
 582             zone = '_msdcs.' + sub_vars['DNSFOREST']
 583         else:
 584             if not normalised_name.endswith('.' + sub_vars['DNSDOMAIN'] + '.'):
 585                 print("Not Calling samba-tool dns for %s (%s), %s not in %s" % (d, op, normalised_name, sub_vars['DNSDOMAIN'] + '.'))
 586                 return False
 587             elif normalised_name.endswith('._msdcs.' + sub_vars['DNSFOREST'] + '.'):
 588                 zone = '_msdcs.' + sub_vars['DNSFOREST']
 589             else:
 590                 zone = sub_vars['DNSDOMAIN']
 591             len_zone = len(zone)+2
 592             short_name = normalised_name[:-len_zone]
 593     else:
 594         len_zone = len(zone)+2
 595         short_name = normalised_name[:-len_zone]
 596
 597     if d.type == "A":
 598         args = [rpc_server_ip, zone, short_name, "A", d.ip]
 599     if d.type == "AAAA":
 600         args = [rpc_server_ip, zone, short_name, "AAAA", d.ip]
 601     if d.type == "SRV":
 602         if op == "add" and d.existing_port is not None:
 603             print("Not handling modify of exising SRV %s using samba-tool" % d)
 604             return False
 605             op = "update"
 606             args = [rpc_server_ip, zone, short_name, "SRV",
 607                     "%s %s %s %s" % (d.existing_weight,
 608                                      d.existing_port, "0", "100"),
 609                     "%s %s %s %s" % (d.dest, d.port, "0", "100")]
 610         else:
 611             args = [rpc_server_ip, zone, short_name, "SRV", "%s %s %s %s" % (d.dest, d.port, "0", "100")]
 612     if d.type == "CNAME":
 613         if d.existing_cname_target is None:
 614             args = [rpc_server_ip, zone, short_name, "CNAME", d.dest]
 615         else:
 616             op = "update"
 617             args = [rpc_server_ip, zone, short_name, "CNAME",
 618                     d.existing_cname_target.rstrip('.'), d.dest]
 619
 620     if d.type == "NS":
 621         args = [rpc_server_ip, zone, short_name, "NS", d.dest]
 622
 623     if smb_conf and args:
 624         args += ["--configfile=" + smb_conf]
 625
 626     global error_count
 627     try:
 628         cmd = cmd_dns()
 629         if opts.verbose:
 630             print("Calling samba-tool dns %s -k no -P %s" % (op, args))
 631         ret = cmd._run("dns", op, "-k", "no", "-P", *args)
 632         if ret == -1:
 633             if opts.fail_immediately:
 634                 sys.exit(1)
 635             error_count = error_count + 1
 636             if opts.verbose:
 637                 print("Failed 'samba-tool dns' based update of %s" % (str(d)))
 638     except Exception as estr:
 639         if opts.fail_immediately:
 640             sys.exit(1)
 641         error_count = error_count + 1
 642         if opts.verbose:
 643             print("Failed 'samba-tool dns' based update: %s : %s" % (str(d), estr))
 644         raise
 645
 646 def rodc_dns_update(d, t, op):
 647     '''a single DNS update via the RODC netlogon call'''
 648     global sub_vars
 649
 650     assert(op in ["add", "delete"])
 651
 652     if opts.verbose:
 653         print("Calling netlogon RODC update for %s" % d)
 654
 655     typemap = {
 656         netlogon.NlDnsLdapAtSite       : netlogon.NlDnsInfoTypeNone,
 657         netlogon.NlDnsGcAtSite         : netlogon.NlDnsDomainNameAlias,
 658         netlogon.NlDnsDsaCname         : netlogon.NlDnsDomainNameAlias,
 659         netlogon.NlDnsKdcAtSite        : netlogon.NlDnsInfoTypeNone,
 660         netlogon.NlDnsDcAtSite         : netlogon.NlDnsInfoTypeNone,
 661         netlogon.NlDnsRfc1510KdcAtSite : netlogon.NlDnsInfoTypeNone,
 662         netlogon.NlDnsGenericGcAtSite  : netlogon.NlDnsDomainNameAlias
 663         }
 664
 665     w = winbind.winbind("irpc:winbind_server", lp)
 666     dns_names = netlogon.NL_DNS_NAME_INFO_ARRAY()
 667     dns_names.count = 1
 668     name = netlogon.NL_DNS_NAME_INFO()
 669     name.type = t
 670     name.dns_domain_info_type = typemap[t]
 671     name.priority = 0
 672     name.weight   = 0
 673     if d.port is not None:
 674         name.port = int(d.port)
 675     if op == "add":
 676         name.dns_register = True
 677     else:
 678         name.dns_register = False
 679     dns_names.names = [ name ]
 680     site_name = text_type(sub_vars['SITE'])
 681
 682     global error_count
 683
 684     try:
 685         ret_names = w.DsrUpdateReadOnlyServerDnsRecords(site_name, default_ttl, dns_names)
 686         if ret_names.names[0].status != 0:
 687             print("Failed to set DNS entry: %s (status %u)" % (d, ret_names.names[0].status))
 688             error_count = error_count + 1
 689     except RuntimeError as reason:
 690         print("Error setting DNS entry of type %u: %s: %s" % (t, d, reason))
 691         error_count = error_count + 1
 692
 693     if error_count != 0 and opts.fail_immediately:
 694         sys.exit(1)
 695
 696
 697 def call_rodc_update(d, op="add"):
 698     '''RODCs need to use the netlogon API for nsupdate'''
 699     global lp, sub_vars
 700
 701     assert(op in ["add", "delete"])
 702
 703     # we expect failure for 3268 if we aren't a GC
 704     if d.port is not None and int(d.port) == 3268:
 705         return
 706
 707     # map the DNS request to a netlogon update type
 708     map = {
 709         netlogon.NlDnsLdapAtSite       : '_ldap._tcp.${SITE}._sites.${DNSDOMAIN}',
 710         netlogon.NlDnsGcAtSite         : '_ldap._tcp.${SITE}._sites.gc._msdcs.${DNSDOMAIN}',
 711         netlogon.NlDnsDsaCname         : '${NTDSGUID}._msdcs.${DNSFOREST}',
 712         netlogon.NlDnsKdcAtSite        : '_kerberos._tcp.${SITE}._sites.dc._msdcs.${DNSDOMAIN}',
 713         netlogon.NlDnsDcAtSite         : '_ldap._tcp.${SITE}._sites.dc._msdcs.${DNSDOMAIN}',
 714         netlogon.NlDnsRfc1510KdcAtSite : '_kerberos._tcp.${SITE}._sites.${DNSDOMAIN}',
 715         netlogon.NlDnsGenericGcAtSite  : '_gc._tcp.${SITE}._sites.${DNSFOREST}'
 716         }
 717
 718     for t in map:
 719         subname = samba.substitute_var(map[t], sub_vars)
 720         if subname.lower() == d.name.lower():
 721             # found a match - do the update
 722             rodc_dns_update(d, t, op)
 723             return
 724     if opts.verbose:
 725         print("Unable to map to netlogon DNS update: %s" % d)
 726
 727
 728 # get the list of DNS entries we should have
 729 if opts.update_list:
 730     dns_update_list = opts.update_list
 731 else:
 732     dns_update_list = lp.private_path('dns_update_list')
 733
 734 if opts.update_cache:
 735     dns_update_cache = opts.update_cache
 736 else:
 737     dns_update_cache = lp.private_path('dns_update_cache')
 738
 739 krb5conf = None
 740 # only change the krb5.conf if we are not in selftest
 741 if 'SOCKET_WRAPPER_DIR' not in os.environ:
 742     # use our private krb5.conf to avoid problems with the wrong domain
 743     # bind9 nsupdate wants the default domain set
 744     krb5conf = lp.private_path('krb5.conf')
 745     os.environ['KRB5_CONFIG'] = krb5conf
 746
 747 file = open(dns_update_list, "r")
 748
 749 if opts.nosubs:
 750     sub_vars = {}
 751 else:
 752     samdb = SamDB(url=lp.samdb_url(), session_info=system_session(), lp=lp)
 753
 754     # get the substitution dictionary
 755     sub_vars = get_subst_vars(samdb)
 756
 757 # build up a list of update commands to pass to nsupdate
 758 update_list = []
 759 dns_list = []
 760 cache_list = []
 761 delete_list = []
 762
 763 dup_set = set()
 764 cache_set = set()
 765
 766 rebuild_cache = False
 767 try:
 768     cfile = open(dns_update_cache, 'r+')
 769 except IOError:
 770     # Perhaps create it
 771     cfile = open(dns_update_cache, 'w+')
 772     # Open it for reading again, in case someone else got to it first
 773     cfile = open(dns_update_cache, 'r+')
 774 fcntl.lockf(cfile, fcntl.LOCK_EX)
 775 for line in cfile:
 776     line = line.strip()
 777     if line == '' or line[0] == "#":
 778         continue
 779     c = parse_dns_line(line, {})
 780     if c is None:
 781         continue
 782     if str(c) not in cache_set:
 783         cache_list.append(c)
 784         cache_set.add(str(c))
 785
 786 site_specific_rec = []
 787
 788 # read each line, and check that the DNS name exists
 789 for line in file:
 790     line = line.strip()
 791
 792     if '${SITE}' in line:
 793         site_specific_rec.append(line)
 794
 795     if line == '' or line[0] == "#":
 796         continue
 797     d = parse_dns_line(line, sub_vars)
 798     if d is None:
 799         continue
 800     if d.type == 'A' and len(IP4s) == 0:
 801         continue
 802     if d.type == 'AAAA' and len(IP6s) == 0:
 803         continue
 804     if str(d) not in dup_set:
 805         dns_list.append(d)
 806         dup_set.add(str(d))
 807
 808 # Perform automatic site coverage by default
 809 auto_coverage = True
 810
 811 if not am_rodc and auto_coverage:
 812     site_names = kcc_utils.uncovered_sites_to_cover(samdb,
 813                                                     samdb.server_site_name())
 814
 815     # Duplicate all site specific records for the uncovered site
 816     for site in site_names:
 817         to_add = [samba.substitute_var(line, {'SITE': site})
 818                   for line in site_specific_rec]
 819
 820         for site_line in to_add:
 821             d = parse_dns_line(site_line,
 822                                sub_vars=sub_vars)
 823             if d is not None and str(d) not in dup_set:
 824                 dns_list.append(d)
 825                 dup_set.add(str(d))
 826
 827 # now expand the entries, if any are A record with ip set to $IP
 828 # then replace with multiple entries, one for each interface IP
 829 for d in dns_list:
 830     if d.ip != "$IP":
 831         continue
 832     if d.type == 'A':
 833         d.ip = IP4s[0]
 834         for i in range(len(IP4s)-1):
 835             d2 = dnsobj(str(d))
 836             d2.ip = IP4s[i+1]
 837             dns_list.append(d2)
 838     if d.type == 'AAAA':
 839         d.ip = IP6s[0]
 840         for i in range(len(IP6s)-1):
 841             d2 = dnsobj(str(d))
 842             d2.ip = IP6s[i+1]
 843             dns_list.append(d2)
 844
 845 # now check if the entries already exist on the DNS server
 846 for d in dns_list:
 847     found = False
 848     for c in cache_list:
 849         if str(c).lower() == str(d).lower():
 850             found = True
 851             break
 852     if not found:
 853         rebuild_cache = True
 854         if opts.verbose:
 855             print("need cache add: %s" % d)
 856     if dns_zone_scavenging:
 857         update_list.append(d)
 858         if opts.verbose:
 859             print("scavenging requires update: %s" % d)
 860     elif opts.all_names:
 861         update_list.append(d)
 862         if opts.verbose:
 863             print("force update: %s" % d)
 864     elif not check_dns_name(d):
 865         update_list.append(d)
 866         if opts.verbose:
 867             print("need update: %s" % d)
 868
 869 for c in cache_list:
 870     found = False
 871     for d in dns_list:
 872         if str(c).lower() == str(d).lower():
 873             found = True
 874             break
 875     if found:
 876         continue
 877     rebuild_cache = True
 878     if opts.verbose:
 879         print("need cache remove: %s" % c)
 880     if not opts.all_names and not check_dns_name(c):
 881         continue
 882     delete_list.append(c)
 883     if opts.verbose:
 884         print("need delete: %s" % c)
 885
 886 if len(delete_list) == 0 and len(update_list) == 0 and not rebuild_cache:
 887     if opts.verbose:
 888         print("No DNS updates needed")
 889     sys.exit(0)
 890 else:
 891     if opts.verbose:
 892         print("%d DNS updates and %d DNS deletes needed" % (len(update_list), len(delete_list)))
 893
 894 use_samba_tool = opts.use_samba_tool
 895 use_nsupdate = opts.use_nsupdate
 896 # get our krb5 creds
 897 if len(delete_list) != 0 or len(update_list) != 0 and not opts.nocreds:
 898     try:
 899         creds = get_credentials(lp)
 900     except RuntimeError as e:
 901         ccachename = None
 902
 903         if sub_vars['IF_RWDNS_DOMAIN'] == "# ":
 904             raise
 905
 906         if use_nsupdate:
 907             raise
 908
 909         print("Failed to get Kerberos credentials, falling back to samba-tool: %s" % e)
 910         use_samba_tool = True
 911
 912
 913 # ask nsupdate to delete entries as needed
 914 for d in delete_list:
 915     if d.rpc or (not use_nsupdate and use_samba_tool):
 916         if opts.verbose:
 917             print("update (samba-tool): %s" % d)
 918         call_samba_tool(d, op="delete", zone=d.zone)
 919
 920     elif am_rodc:
 921         if d.name.lower() == domain.lower():
 922             if opts.verbose:
 923                 print("skip delete (rodc): %s" % d)
 924             continue
 925         if not d.type in [ 'A', 'AAAA' ]:
 926             if opts.verbose:
 927                 print("delete (rodc): %s" % d)
 928             call_rodc_update(d, op="delete")
 929         else:
 930             if opts.verbose:
 931                 print("delete (nsupdate): %s" % d)
 932             call_nsupdate(d, op="delete")
 933     else:
 934         if opts.verbose:
 935             print("delete (nsupdate): %s" % d)
 936         call_nsupdate(d, op="delete")
 937
 938 # ask nsupdate to add entries as needed
 939 for d in update_list:
 940     if d.rpc or (not use_nsupdate and use_samba_tool):
 941         if opts.verbose:
 942             print("update (samba-tool): %s" % d)
 943         call_samba_tool(d, zone=d.zone)
 944
 945     elif am_rodc:
 946         if d.name.lower() == domain.lower():
 947             if opts.verbose:
 948                 print("skip (rodc): %s" % d)
 949             continue
 950         if not d.type in [ 'A', 'AAAA' ]:
 951             if opts.verbose:
 952                 print("update (rodc): %s" % d)
 953             call_rodc_update(d)
 954         else:
 955             if opts.verbose:
 956                 print("update (nsupdate): %s" % d)
 957             call_nsupdate(d)
 958     else:
 959         if opts.verbose:
 960             print("update(nsupdate): %s" % d)
 961         call_nsupdate(d)
 962
 963 if rebuild_cache:
 964     print("Rebuilding cache at %s" % dns_update_cache)
 965     (file_dir, file_name) = os.path.split(dns_update_cache)
 966     (tmp_fd, tmpfile) = tempfile.mkstemp(dir=file_dir, prefix=file_name, suffix="XXXXXX")
 967     wfile = os.fdopen(tmp_fd, 'a')
 968     for d in dns_list:
 969         if opts.verbose:
 970             print("Adding %s to %s" % (str(d), file_name))
 971         wfile.write(str(d)+"\n")
 972     os.rename(tmpfile, dns_update_cache)
 973 fcntl.lockf(cfile, fcntl.LOCK_UN)
 974
 975 # delete the ccache if we created it
 976 if ccachename is not None:
 977     os.unlink(ccachename)
 978
 979 if error_count != 0:
 980     print("Failed update of %u entries" % error_count)
 981 sys.exit(error_count)