s4-provision: Fill msDS-NC-Replica-Locations attribute in DNS provisioning
[amitay/samba.git] / source4 / scripting / python / samba / provision / sambadns.py
1 # Unix SMB/CIFS implementation.
2 # backend code for provisioning DNS for a Samba4 server
3 #
4 # Copyright (C) Kai Blin <kai@samba.org> 2011
5 # Copyright (C) Amitay Isaacs <amitay@gmail.com> 2011
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 """DNS-related provisioning"""
22
23 import os
24 import uuid
25 import ldb
26 import samba
27 from samba.ndr import ndr_pack, ndr_unpack
28 from samba import read_and_sub_file
29 from samba.dcerpc import dnsp, misc
30 from samba.dsdb import (
31     DS_DOMAIN_FUNCTION_2000,
32     DS_DOMAIN_FUNCTION_2003,
33     DS_DOMAIN_FUNCTION_2008,
34     DS_DOMAIN_FUNCTION_2008_R2
35     )
36
37
38 def add_ldif(ldb, ldif_file, subst_vars, controls=["relax:0"]):
39     ldif_file_path = os.path.join(samba.param.setup_dir(), ldif_file)
40     data = read_and_sub_file(ldif_file_path, subst_vars)
41     ldb.add_ldif(data, controls)
42
43 def modify_ldif(ldb, ldif_file, subst_vars, controls=["relax:0"]):
44     ldif_file_path = os.path.join(samba.param.setup_dir(), ldif_file)
45     data = read_and_sub_file(ldif_file_path, subst_vars)
46     ldb.modify_ldif(data, controls)
47
48 def get_domainguid(samdb, domaindn):
49     res = samdb.search(base=domaindn, scope=ldb.SCOPE_BASE, attrs=["objectGUID"])
50     domainguid =  str(ndr_unpack(misc.GUID, res[0]["objectGUID"][0]))
51     return domainguid
52
53 def get_ntdsguid(samdb, domaindn):
54     configdn = "CN=Configuration,%s" % domaindn
55
56     res1 = samdb.search(base="OU=Domain Controllers,%s" % domaindn, scope=ldb.SCOPE_ONELEVEL,
57                         attrs=["dNSHostName"])
58
59     res2 = samdb.search(expression="serverReference=%s" % res1[0].dn, base=configdn)
60
61     res3 = samdb.search(base="CN=NTDS Settings,%s" % res2[0].dn, scope=ldb.SCOPE_BASE,
62                         attrs=["objectGUID"])
63     ntdsguid = str(ndr_unpack(misc.GUID, res3[0]["objectGUID"][0]))
64     return ntdsguid
65
66
67 class ARecord(dnsp.DnssrvRpcRecord):
68     def __init__(self, ip_addr, serial=1, ttl=900):
69         super(ARecord, self).__init__()
70         self.wType = dnsp.DNS_TYPE_A
71         self.dwSerial = serial
72         self.dwTtlSeconds = ttl
73         self.data = ip_addr
74
75 class AAAARecord(dnsp.DnssrvRpcRecord):
76     def __init__(self, ip6_addr, serial=1, ttl=900):
77         super(AAAARecord, self).__init__()
78         self.wType = dnsp.DNS_TYPE_AAAA
79         self.dwSerial = serial
80         self.dwTtlSeconds = ttl
81         self.data = ip6_addr
82
83 class CNameRecord(dnsp.DnssrvRpcRecord):
84     def __init__(self, cname, serial=1, ttl=900):
85         super(CNameRecord, self).__init__()
86         self.wType = dnsp.DNS_TYPE_CNAME
87         self.dwSerial = serial
88         self.dwTtlSeconds = ttl
89         self.data = cname
90
91 class NSRecord(dnsp.DnssrvRpcRecord):
92     def __init__(self, dns_server, serial=1, ttl=900):
93         super(NSRecord, self).__init__()
94         self.wType = dnsp.DNS_TYPE_NS
95         self.dwSerial = serial
96         self.dwTtlSeconds = ttl
97         self.data = dns_server
98
99 class RootNSRecord(dnsp.DnssrvRpcRecord):
100     def __init__(self, dns_server, serial=1, ttl=3600):
101         super(RootNSRecord, self).__init__()
102         self.wType = dnsp.DNS_TYPE_NS
103         self.dwSerial = serial
104         self.dwTtlSeconds = ttl
105         self.data = dns_server
106         self.rank = dnsp.DNS_RANK_ROOT_HINT
107
108 class SOARecord(dnsp.DnssrvRpcRecord):
109     def __init__(self, mname, rname, serial=1, refresh=900, retry=600,
110                  expire=86400, minimum=3600, ttl=3600):
111         super(SOARecord, self).__init__()
112         self.wType = dnsp.DNS_TYPE_SOA
113         self.dwSerial = serial
114         self.dwTtlSeconds = ttl
115         soa = dnsp.soa()
116         soa.serial = serial
117         soa.refresh = refresh
118         soa.retry = retry
119         soa.expire = expire
120         soa.mname = mname
121         soa.rname = rname
122         self.data = soa
123
124 class SRVRecord(dnsp.DnssrvRpcRecord):
125     def __init__(self, target, port, priority=0, weight=100, serial=1, ttl=900):
126         super(SRVRecord, self).__init__()
127         self.wType = dnsp.DNS_TYPE_SRV
128         self.dwSerial = serial
129         self.dwTtlSeconds = ttl
130         srv = dnsp.srv()
131         srv.nameTarget = target
132         srv.wPort = port
133         srv.wPriority = priority
134         srv.wWeight = weight
135         self.data = srv
136
137
138 def setup_dns_partitions(samdb, domaindn, forestdn, configdn, serverdn):
139
140     # FIXME: Default security descriptor for Domain-DNS objectCategory is different in
141     #        our documentation from windows
142
143     domainzone_dn = "DC=DomainDnsZones,%s" % domaindn
144     forestzone_dn = "DC=ForestDnsZones,%s" % forestdn
145
146     add_ldif(samdb, "provision_dnszones_partitions.ldif", {
147         "DOMAINZONE_DN": domainzone_dn,
148         "FORESTZONE_DN": forestzone_dn,
149         })
150
151     domainzone_guid = get_domainguid(samdb, domainzone_dn)
152     forestzone_guid = get_domainguid(samdb, forestzone_dn)
153
154     domainzone_guid = str(uuid.uuid4())
155     forestzone_guid = str(uuid.uuid4())
156
157     domainzone_dns = ldb.Dn(samdb, domainzone_dn).canonical_ex_str().strip()
158     forestzone_dns = ldb.Dn(samdb, forestzone_dn).canonical_ex_str().strip()
159
160     add_ldif(samdb, "provision_dnszones_add.ldif", {
161         "DOMAINZONE_DN": domainzone_dn,
162         "FORESTZONE_DN": forestzone_dn,
163         "DOMAINZONE_GUID": domainzone_guid,
164         "FORESTZONE_GUID": forestzone_guid,
165         "DOMAINZONE_DNS": domainzone_dns,
166         "FORESTZONE_DNS": forestzone_dns,
167         "CONFIGDN": configdn,
168         "SERVERDN": serverdn,
169         })
170
171     modify_ldif(samdb, "provision_dnszones_modify.ldif", {
172         "CONFIGDN": configdn,
173         "SERVERDN": serverdn,
174         "DOMAINZONE_DN": domainzone_dn,
175         "FORESTZONE_DN": forestzone_dn,
176     })
177
178
179 def add_dns_accounts(samdb, domaindn):
180     add_ldif(samdb, "provision_dns_accounts_add.ldif", {
181         "DOMAINDN": domaindn,
182         })
183
184 def add_dns_container(samdb, domaindn, prefix):
185     # CN=MicrosoftDNS,<PREFIX>,<DOMAINDN>
186     msg = ldb.Message(ldb.Dn(samdb, "CN=MicrosoftDNS,%s,%s" % (prefix, domaindn)))
187     msg["objectClass"] = ["top", "container"]
188     msg["displayName"] = ldb.MessageElement("DNS Servers", ldb.FLAG_MOD_ADD, "displayName")
189     samdb.add(msg)
190
191
192 def add_rootservers(samdb, domaindn, prefix):
193     rootservers = {}
194     rootservers["a.root-servers.net"] = "198.41.0.4"
195     rootservers["b.root-servers.net"] = "192.228.79.201"
196     rootservers["c.root-servers.net"] = "192.33.4.12"
197     rootservers["d.root-servers.net"] = "128.8.10.90"
198     rootservers["e.root-servers.net"] = "192.203.230.10"
199     rootservers["f.root-servers.net"] = "192.5.5.241"
200     rootservers["g.root-servers.net"] = "192.112.36.4"
201     rootservers["h.root-servers.net"] = "128.63.2.53"
202     rootservers["i.root-servers.net"] = "192.36.148.17"
203     rootservers["j.root-servers.net"] = "192.58.128.30"
204     rootservers["k.root-servers.net"] = "193.0.14.129"
205     rootservers["l.root-servers.net"] = "199.7.83.42"
206     rootservers["m.root-servers.net"] = "202.12.27.33"
207
208     rootservers_v6 = {}
209     rootservers_v6["a.root-servers.net"] = "2001:503:ba3e::2:30"
210     rootservers_v6["f.root-servers.net"] = "2001:500:2f::f"
211     rootservers_v6["h.root-servers.net"] = "2001:500:1::803f:235"
212     rootservers_v6["j.root-servers.net"] = "2001:503:c27::2:30"
213     rootservers_v6["k.root-servers.net"] = "2001:7fd::1"
214     rootservers_v6["m.root-servers.net"] = "2001:dc3::35"
215
216     container_dn = "DC=RootDNSServers,CN=MicrosoftDNS,%s,%s" % (prefix, domaindn)
217
218     # Add DC=RootDNSServers,CN=MicrosoftDNS,<PREFIX>,<DOMAINDN>
219     msg = ldb.Message(ldb.Dn(samdb, container_dn))
220     msg["objectClass"] = ["top", "dnsZone"]
221     samdb.add(msg)
222
223     # Add DC=@,DC=RootDNSServers,CN=MicrosoftDNS,<PREFIX>,<DOMAINDN>
224     record = []
225     for rserver in rootservers:
226         record.append(ndr_pack(RootNSRecord(rserver, serial=0, ttl=0)))
227
228     msg = ldb.Message(ldb.Dn(samdb, "DC=@,%s" % container_dn))
229     msg["objectClass"] = ["top", "dnsNode"]
230     msg["dnsRecord"] = ldb.MessageElement(record, ldb.FLAG_MOD_ADD, "dnsRecord")
231     samdb.add(msg)
232
233     # Add DC=<rootserver>,DC=RootDNSServers,CN=MicrosoftDNS,<PREFIX>,<DOMAINDN>
234     for rserver in rootservers:
235         record = [ndr_pack(ARecord(rootservers[rserver], serial=0, ttl=0))]
236         # Add AAAA record as well (How does W2K* add IPv6 records?)
237         #if rserver in rootservers_v6:
238         #    record.append(ndr_pack(AAAARecord(rootservers_v6[rserver], serial=0, ttl=0)))
239         msg = ldb.Message(ldb.Dn(samdb, "DC=%s,%s" % (rserver, container_dn)))
240         msg["objectClass"] = ["top", "dnsNode"]
241         msg["dnsRecord"] = ldb.MessageElement(record, ldb.FLAG_MOD_ADD, "dnsRecord")
242         samdb.add(msg)
243
244 def add_at_record(samdb, container_dn, prefix, hostname, dnsdomain, hostip, hostip6):
245
246     fqdn_hostname = "%s.%s" % (hostname, dnsdomain)
247
248     at_records = []
249
250     # SOA record
251     at_soa_record = SOARecord(fqdn_hostname, "hostmaster.%s" % dnsdomain)
252     at_records.append(ndr_pack(at_soa_record))
253
254     # NS record
255     at_ns_record = NSRecord(fqdn_hostname)
256     at_records.append(ndr_pack(at_ns_record))
257
258     if hostip is not None:
259         # A record
260         at_a_record = ARecord(hostip)
261         at_records.append(ndr_pack(at_a_record))
262
263     if hostip6 is not None:
264         # AAAA record
265         at_aaaa_record = AAAARecord(hostip6)
266         at_records.append(ndr_pack(at_aaaa_record))
267
268     msg = ldb.Message(ldb.Dn(samdb, "DC=@,%s" % container_dn))
269     msg["objectClass"] = ["top", "dnsNode"]
270     msg["dnsRecord"] = ldb.MessageElement(at_records, ldb.FLAG_MOD_ADD, "dnsRecord")
271     samdb.add(msg)
272
273 def add_srv_record(samdb, container_dn, prefix, host, port):
274     srv_record = SRVRecord(host, port)
275     msg = ldb.Message(ldb.Dn(samdb, "%s,%s" % (prefix, container_dn)))
276     msg["objectClass"] = ["top", "dnsNode"]
277     msg["dnsRecord"] = ldb.MessageElement(ndr_pack(srv_record), ldb.FLAG_MOD_ADD, "dnsRecord")
278     samdb.add(msg)
279
280 def add_ns_record(samdb, container_dn, prefix, host):
281     ns_record = NSRecord(host)
282     msg = ldb.Message(ldb.Dn(samdb, "%s,%s" % (prefix, container_dn)))
283     msg["objectClass"] = ["top", "dnsNode"]
284     msg["dnsRecord"] = ldb.MessageElement(ndr_pack(ns_record), ldb.FLAG_MOD_ADD, "dnsRecord")
285     samdb.add(msg)
286
287 def add_cname_record(samdb, container_dn, prefix, host):
288     cname_record = CNameRecord(host)
289     msg = ldb.Message(ldb.Dn(samdb, "%s,%s" % (prefix, container_dn)))
290     msg["objectClass"] = ["top", "dnsNode"]
291     msg["dnsRecord"] = ldb.MessageElement(ndr_pack(cname_record), ldb.FLAG_MOD_ADD, "dnsRecord")
292     samdb.add(msg)
293
294 def add_host_record(samdb, container_dn, prefix, hostip, hostip6):
295     host_records = []
296     if hostip:
297         a_record = ARecord(hostip)
298         host_records.append(ndr_pack(a_record))
299     if hostip6:
300         aaaa_record = AAAARecord(hostip6)
301         host_records.append(ndr_pack(aaaa_record))
302     if host_records:
303         msg = ldb.Message(ldb.Dn(samdb, "%s,%s" % (prefix, container_dn)))
304         msg["objectClass"] = ["top", "dnsNode"]
305         msg["dnsRecord"] = ldb.MessageElement(host_records, ldb.FLAG_MOD_ADD, "dnsRecord")
306         samdb.add(msg)
307
308 def add_domain_record(samdb, domaindn, prefix, dnsdomain):
309     # DC=<DNSDOMAIN>,CN=MicrosoftDNS,<PREFIX>,<DOMAINDN>
310     msg = ldb.Message(ldb.Dn(samdb, "DC=%s,CN=MicrosoftDNS,%s,%s" % (dnsdomain, prefix, domaindn)))
311     msg["objectClass"] = ["top", "dnsZone"]
312     samdb.add(msg)
313
314 def add_msdcs_record(samdb, forestdn, prefix, dnsforest):
315     # DC=_msdcs.<DNSFOREST>,CN=MicrosoftDNS,<PREFIX>,<FORESTDN>
316     msg = ldb.Message(ldb.Dn(samdb, "DC=_msdcs.%s,CN=MicrosoftDNS,%s,%s" %
317                                     (dnsforest, prefix, forestdn)))
318     msg["objectClass"] = ["top", "dnsZone"]
319     samdb.add(msg)
320
321
322 def add_dc_domain_records(samdb, domaindn, prefix, site, dnsdomain, hostname, hostip, hostip6):
323
324     fqdn_hostname = "%s.%s" % (hostname, dnsdomain)
325
326     # Set up domain container - DC=<DNSDOMAIN>,CN=MicrosoftDNS,<PREFIX>,<DOMAINDN>
327     domain_container_dn = ldb.Dn(samdb, "DC=%s,CN=MicrosoftDNS,%s,%s" %
328                                     (dnsdomain, prefix, domaindn))
329
330     # DC=@ record
331     add_at_record(samdb, domain_container_dn, "DC=@", hostname, dnsdomain, hostip, hostip6)
332
333     # DC=<HOSTNAME> record
334     add_host_record(samdb, domain_container_dn, "DC=%s" % hostname, hostip, hostip6)
335
336     # DC=_kerberos._tcp record
337     add_srv_record(samdb, domain_container_dn, "DC=_kerberos._tcp", fqdn_hostname, 88)
338
339     # DC=_kerberos._tcp.<SITENAME>._sites record
340     add_srv_record(samdb, domain_container_dn, "DC=_kerberos._tcp.%s._sites" % site,
341                     fqdn_hostname, 88)
342
343     # DC=_kerberos._udp record
344     add_srv_record(samdb, domain_container_dn, "DC=_kerberos._udp", fqdn_hostname, 88)
345
346     # DC=_kpasswd._tcp record
347     add_srv_record(samdb, domain_container_dn, "DC=_kpasswd._tcp", fqdn_hostname, 464)
348
349     # DC=_kpasswd._udp record
350     add_srv_record(samdb, domain_container_dn, "DC=_kpasswd._udp", fqdn_hostname, 464)
351
352     # DC=_ldap._tcp record
353     add_srv_record(samdb, domain_container_dn, "DC=_ldap._tcp", fqdn_hostname, 389)
354
355     # DC=_ldap._tcp.<SITENAME>._sites record
356     add_srv_record(samdb, domain_container_dn, "DC=_ldap._tcp.%s._sites" % site,
357                     fqdn_hostname, 389)
358
359     # FIXME: The number of SRV records depend on the various roles this DC has.
360     #        _gc and _msdcs records are added if the we are the forest dc and not subdomain dc
361     #
362     # Assumption: current DC is GC and add all the entries
363
364     # DC=_gc._tcp record
365     add_srv_record(samdb, domain_container_dn, "DC=_gc._tcp", fqdn_hostname, 3268)
366
367     # DC=_gc._tcp.<SITENAME>,_sites record
368     add_srv_record(samdb, domain_container_dn, "DC=_gc._tcp.%s._sites" % site, fqdn_hostname, 3268)
369
370     # DC=_msdcs record
371     add_ns_record(samdb, domain_container_dn, "DC=_msdcs", fqdn_hostname)
372
373     # FIXME: Following entries are added only if DomainDnsZones and ForestDnsZones partitions
374     #        are created
375     #
376     # Assumption: Additional entries won't hurt on os_level = 2000
377
378     # DC=_ldap._tcp.<SITENAME>._sites.DomainDnsZones
379     add_srv_record(samdb, domain_container_dn, "DC=_ldap._tcp.%s._sites.DomainDnsZones" % site,
380                     fqdn_hostname, 389)
381
382     # DC=_ldap._tcp.<SITENAME>._sites.ForestDnsZones
383     add_srv_record(samdb, domain_container_dn, "DC=_ldap._tcp.%s._sites.ForestDnsZones" % site,
384                     fqdn_hostname, 389)
385
386     # DC=_ldap._tcp.DomainDnsZones
387     add_srv_record(samdb, domain_container_dn, "DC=_ldap._tcp.DomainDnsZones",
388                     fqdn_hostname, 389)
389
390     # DC=_ldap._tcp.ForestDnsZones
391     add_srv_record(samdb, domain_container_dn, "DC=_ldap._tcp.ForestDnsZones",
392                     fqdn_hostname, 389)
393
394     # DC=DomainDnsZones
395     add_host_record(samdb, domain_container_dn, "DC=DomainDnsZones", hostip, hostip6)
396
397     # DC=ForestDnsZones
398     add_host_record(samdb, domain_container_dn, "DC=ForestDnsZones", hostip, hostip6)
399
400
401 def add_dc_msdcs_records(samdb, forestdn, prefix, site, dnsforest, hostname,
402                             hostip, hostip6, domainguid, ntdsguid):
403
404     fqdn_hostname = "%s.%s" % (hostname, dnsforest)
405
406     # Set up forest container - DC=<DNSDOMAIN>,CN=MicrosoftDNS,<PREFIX>,<DOMAINDN>
407     forest_container_dn = ldb.Dn(samdb, "DC=_msdcs.%s,CN=MicrosoftDNS,%s,%s" %
408                                     (dnsforest, prefix, forestdn))
409
410     # DC=@ record
411     add_at_record(samdb, forest_container_dn, "DC=@", hostname, dnsforest, None, None)
412
413     # DC=_kerberos._tcp.dc record
414     add_srv_record(samdb, forest_container_dn, "DC=_kerberos._tcp.dc", fqdn_hostname, 88)
415
416     # DC=_kerberos._tcp.<SITENAME>._sites.dc record
417     add_srv_record(samdb, forest_container_dn, "DC=_kerberos._tcp.%s._sites.dc" % site,
418                     fqdn_hostname, 88)
419
420     # DC=_ldap._tcp.dc record
421     add_srv_record(samdb, forest_container_dn, "DC=_ldap._tcp.dc", fqdn_hostname, 389)
422
423     # DC=_ldap._tcp.<SITENAME>._sites.dc record
424     add_srv_record(samdb, forest_container_dn, "DC=_ldap._tcp.%s._sites.dc" % site,
425                     fqdn_hostname, 389)
426
427     # DC=_ldap._tcp.<SITENAME>._sites.gc record
428     add_srv_record(samdb, forest_container_dn, "DC=_ldap._tcp.%s._sites.gc" % site,
429                     fqdn_hostname, 3268)
430
431     # DC=_ldap._tcp.gc record
432     add_srv_record(samdb, forest_container_dn, "DC=_ldap._tcp.gc", fqdn_hostname, 3268)
433
434     # DC=_ldap._tcp.pdc record
435     add_srv_record(samdb, forest_container_dn, "DC=_ldap._tcp.pdc", fqdn_hostname, 389)
436
437     # DC=gc record
438     add_host_record(samdb, forest_container_dn, "DC=gc", hostip, hostip6)
439
440     # DC=_ldap._tcp.<DOMAINGUID>.domains record
441     add_srv_record(samdb, forest_container_dn, "DC=_ldap._tcp.%s.domains" % domainguid,
442                     fqdn_hostname, 389)
443
444     # DC=<NTDSGUID>
445     add_cname_record(samdb, forest_container_dn, "DC=%s" % ntdsguid, fqdn_hostname)
446
447
448 def setup_ad_dns(samdb, names, logger, hostip=None, hostip6=None, dns_backend=None,
449                 os_level=None):
450     """Provision DNS information (assuming GC role)
451
452     :param samdb: LDB object connected to sam.ldb file
453     :param names: Names shortcut
454     :param logger: Logger object
455     :param hostip: IPv4 address
456     :param hostip6: IPv6 address
457     :param dns_backend: Type of DNS backend
458     :param os_level: Functional level (treated as os level)
459     """
460
461     if dns_backend is None:
462         dns_backend = "BIND9"
463         logger.info("Assuming bind9 DNS server backend")
464
465     # If dns_backend is BIND9
466     #   Populate only CN=MicrosoftDNS,CN=System,<DOMAINDN>
467     #
468     # If dns_backend is SAMBA or BIND9_DLZ 
469     #   Populate DNS partitions
470
471     if os_level is None:
472         os_level = DS_DOMAIN_FUNCTION_2003
473
474     # If os_level < 2003 (DS_DOMAIN_FUNCTION_2000)
475     #   All dns records are in CN=MicrosoftDNS,CN=System,<DOMAINDN>
476     #
477     # If os_level >= 2003 (DS_DOMAIN_FUNCTION_2003, DS_DOMAIN_FUNCTION_2008,
478     #                        DS_DOMAIN_FUNCTION_2008_R2)
479     #   Root server records are in CN=MicrosoftDNS,CN=System,<DOMAINDN>
480     #   Domain records are in CN=MicrosoftDNS,CN=System,<DOMAINDN>
481     #   Domain records are in CN=MicrosoftDNS,DC=DomainDnsZones,<DOMAINDN>
482     #   Forest records are in CN=MicrosoftDNS,DC=ForestDnsZones,<DOMAINDN>
483
484     domaindn = names.domaindn
485     forestdn = samdb.get_root_basedn().get_linearized()
486
487     dnsdomain = names.dnsdomain.lower()
488     dnsforest = dnsdomain
489
490     hostname = names.netbiosname.lower()
491     site = names.sitename
492
493     domainguid = get_domainguid(samdb, domaindn)
494     ntdsguid = get_ntdsguid(samdb, domaindn)
495
496     # Add dns accounts (DnsAdmins, DnsUpdateProxy) in domain
497     logger.info("Adding DNS accounts")
498     add_dns_accounts(samdb, domaindn)
499
500     logger.info("Populating CN=System,%s" % domaindn)
501
502     # Set up MicrosoftDNS container
503     add_dns_container(samdb, domaindn, "CN=System")
504
505     # Add root servers
506     add_rootservers(samdb, domaindn, "CN=System")
507
508     if os_level == DS_DOMAIN_FUNCTION_2000:
509
510         # Add domain record
511         add_domain_record(samdb, domaindn, "CN=System", dnsdomain)
512
513         # Add DNS records for a DC in domain
514         add_dc_domain_records(samdb, domaindn, "CN=System", site, dnsdomain,
515                                 hostname, hostip, hostip6)
516
517     elif (dns_backend == "SAMBA" or dns_backend == "BIND9_DLZ") and (
518             os_level == DS_DOMAIN_FUNCTION_2003 or
519             os_level == DS_DOMAIN_FUNCTION_2008 or
520             os_level == DS_DOMAIN_FUNCTION_2008_R2):
521
522         # Set up additional partitions (DomainDnsZones, ForstDnsZones)
523         logger.info("Creating DomainDnsZones and ForestDnsZones partitions")
524         setup_dns_partitions(samdb, domaindn, forestdn, names.configdn, names.serverdn)
525
526         ##### Set up DC=DomainDnsZones,<DOMAINDN>
527         logger.info("Populating DomainDnsZones partition")
528
529         # Set up MicrosoftDNS container
530         add_dns_container(samdb, domaindn, "DC=DomainDnsZones")
531
532         # Add rootserver records
533         add_rootservers(samdb, domaindn, "DC=DomainDnsZones")
534
535         # Add domain record
536         add_domain_record(samdb, domaindn, "DC=DomainDnsZones", dnsdomain)
537
538         # Add DNS records for a DC in domain
539         add_dc_domain_records(samdb, domaindn, "DC=DomainDnsZones", site, dnsdomain,
540                                 hostname, hostip, hostip6)
541
542         ##### Set up DC=ForestDnsZones,<DOMAINDN>
543         logger.info("Populating ForestDnsZones partition")
544
545         # Set up MicrosoftDNS container
546         add_dns_container(samdb, forestdn, "DC=ForestDnsZones")
547
548         # Add _msdcs record
549         add_msdcs_record(samdb, forestdn, "DC=ForestDnsZones", dnsforest)
550
551         # Add DNS records for a DC in forest
552         add_dc_msdcs_records(samdb, forestdn, "DC=ForestDnsZones", site, dnsforest,
553                                 hostname, hostip, hostip6, domainguid, ntdsguid)