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