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 shutil
  26 import time
  27 import ldb
  28 from base64 import b64encode
  29 import subprocess
  30 import samba
  31 from samba.tdb_util import tdb_copy
  32 from samba.ndr import ndr_pack, ndr_unpack
  33 from samba import setup_file
  34 from samba.dcerpc import dnsp, misc, security
  35 from samba.dsdb import (
  36     DS_DOMAIN_FUNCTION_2000,
  37     DS_DOMAIN_FUNCTION_2003,
  38     DS_DOMAIN_FUNCTION_2008_R2,
  39     DS_DOMAIN_FUNCTION_2012_R2
  40     )
  41 from samba.descriptor import (
  42     get_domain_descriptor,
  43     get_domain_delete_protected1_descriptor,
  44     get_domain_delete_protected2_descriptor,
  45     get_dns_partition_descriptor,
  46     get_dns_forest_microsoft_dns_descriptor,
  47     get_dns_domain_microsoft_dns_descriptor
  48     )
  49 from samba.provision.common import (
  50     setup_path,
  51     setup_add_ldif,
  52     setup_modify_ldif,
  53     setup_ldb,
  54     FILL_FULL,
  55     FILL_SUBDOMAIN,
  56     FILL_NT4SYNC,
  57     FILL_DRS,
  58     )
  59
  60
  61 def get_domainguid(samdb, domaindn):
  62     res = samdb.search(base=domaindn, scope=ldb.SCOPE_BASE, attrs=["objectGUID"])
  63     domainguid =  str(ndr_unpack(misc.GUID, res[0]["objectGUID"][0]))
  64     return domainguid
  65
  66
  67 def get_dnsadmins_sid(samdb, domaindn):
  68     res = samdb.search(base="CN=DnsAdmins,CN=Users,%s" % domaindn, scope=ldb.SCOPE_BASE,
  69                        attrs=["objectSid"])
  70     dnsadmins_sid = ndr_unpack(security.dom_sid, res[0]["objectSid"][0])
  71     return dnsadmins_sid
  72
  73
  74 class ARecord(dnsp.DnssrvRpcRecord):
  75
  76     def __init__(self, ip_addr, serial=1, ttl=900, rank=dnsp.DNS_RANK_ZONE):
  77         super(ARecord, self).__init__()
  78         self.wType = dnsp.DNS_TYPE_A
  79         self.rank = rank
  80         self.dwSerial = serial
  81         self.dwTtlSeconds = ttl
  82         self.data = ip_addr
  83
  84
  85 class AAAARecord(dnsp.DnssrvRpcRecord):
  86
  87     def __init__(self, ip6_addr, serial=1, ttl=900, rank=dnsp.DNS_RANK_ZONE):
  88         super(AAAARecord, self).__init__()
  89         self.wType = dnsp.DNS_TYPE_AAAA
  90         self.rank = rank
  91         self.dwSerial = serial
  92         self.dwTtlSeconds = ttl
  93         self.data = ip6_addr
  94
  95
  96 class CNameRecord(dnsp.DnssrvRpcRecord):
  97
  98     def __init__(self, cname, serial=1, ttl=900, rank=dnsp.DNS_RANK_ZONE):
  99         super(CNameRecord, self).__init__()
 100         self.wType = dnsp.DNS_TYPE_CNAME
 101         self.rank = rank
 102         self.dwSerial = serial
 103         self.dwTtlSeconds = ttl
 104         self.data = cname
 105
 106
 107 class NSRecord(dnsp.DnssrvRpcRecord):
 108
 109     def __init__(self, dns_server, serial=1, ttl=900, rank=dnsp.DNS_RANK_ZONE):
 110         super(NSRecord, self).__init__()
 111         self.wType = dnsp.DNS_TYPE_NS
 112         self.rank = rank
 113         self.dwSerial = serial
 114         self.dwTtlSeconds = ttl
 115         self.data = dns_server
 116
 117
 118 class SOARecord(dnsp.DnssrvRpcRecord):
 119
 120     def __init__(self, mname, rname, serial=1, refresh=900, retry=600,
 121                  expire=86400, minimum=3600, ttl=3600, rank=dnsp.DNS_RANK_ZONE):
 122         super(SOARecord, self).__init__()
 123         self.wType = dnsp.DNS_TYPE_SOA
 124         self.rank = rank
 125         self.dwSerial = serial
 126         self.dwTtlSeconds = ttl
 127         soa = dnsp.soa()
 128         soa.serial = serial
 129         soa.refresh = refresh
 130         soa.retry = retry
 131         soa.expire = expire
 132         soa.mname = mname
 133         soa.rname = rname
 134         soa.minimum = minimum
 135         self.data = soa
 136
 137
 138 class SRVRecord(dnsp.DnssrvRpcRecord):
 139
 140     def __init__(self, target, port, priority=0, weight=100, serial=1, ttl=900,
 141                 rank=dnsp.DNS_RANK_ZONE):
 142         super(SRVRecord, self).__init__()
 143         self.wType = dnsp.DNS_TYPE_SRV
 144         self.rank = rank
 145         self.dwSerial = serial
 146         self.dwTtlSeconds = ttl
 147         srv = dnsp.srv()
 148         srv.nameTarget = target
 149         srv.wPort = port
 150         srv.wPriority = priority
 151         srv.wWeight = weight
 152         self.data = srv
 153
 154
 155 class TXTRecord(dnsp.DnssrvRpcRecord):
 156
 157     def __init__(self, slist, serial=1, ttl=900, rank=dnsp.DNS_RANK_ZONE):
 158         super(TXTRecord, self).__init__()
 159         self.wType = dnsp.DNS_TYPE_TXT
 160         self.rank = rank
 161         self.dwSerial = serial
 162         self.dwTtlSeconds = ttl
 163         stringlist = dnsp.string_list()
 164         stringlist.count = len(slist)
 165         stringlist.str = slist
 166         self.data = stringlist
 167
 168
 169 class TypeProperty(dnsp.DnsProperty):
 170
 171     def __init__(self, zone_type=dnsp.DNS_ZONE_TYPE_PRIMARY):
 172         super(TypeProperty, self).__init__()
 173         self.wDataLength = 1
 174         self.version = 1
 175         self.id = dnsp.DSPROPERTY_ZONE_TYPE
 176         self.data = zone_type
 177
 178
 179 class AllowUpdateProperty(dnsp.DnsProperty):
 180
 181     def __init__(self, allow_update=dnsp.DNS_ZONE_UPDATE_SECURE):
 182         super(AllowUpdateProperty, self).__init__()
 183         self.wDataLength = 1
 184         self.version = 1
 185         self.id = dnsp.DSPROPERTY_ZONE_ALLOW_UPDATE
 186         self.data = allow_update
 187
 188
 189 class SecureTimeProperty(dnsp.DnsProperty):
 190
 191     def __init__(self, secure_time=0):
 192         super(SecureTimeProperty, self).__init__()
 193         self.wDataLength = 1
 194         self.version = 1
 195         self.id = dnsp.DSPROPERTY_ZONE_SECURE_TIME
 196         self.data = secure_time
 197
 198
 199 class NorefreshIntervalProperty(dnsp.DnsProperty):
 200
 201     def __init__(self, norefresh_interval=0):
 202         super(NorefreshIntervalProperty, self).__init__()
 203         self.wDataLength = 1
 204         self.version = 1
 205         self.id = dnsp.DSPROPERTY_ZONE_NOREFRESH_INTERVAL
 206         self.data = norefresh_interval
 207
 208
 209 class RefreshIntervalProperty(dnsp.DnsProperty):
 210
 211     def __init__(self, refresh_interval=0):
 212         super(RefreshIntervalProperty, self).__init__()
 213         self.wDataLength = 1
 214         self.version = 1
 215         self.id = dnsp.DSPROPERTY_ZONE_REFRESH_INTERVAL
 216         self.data = refresh_interval
 217
 218
 219 class AgingStateProperty(dnsp.DnsProperty):
 220
 221     def __init__(self, aging_enabled=0):
 222         super(AgingStateProperty, self).__init__()
 223         self.wDataLength = 1
 224         self.version = 1
 225         self.id = dnsp.DSPROPERTY_ZONE_AGING_STATE
 226         self.data = aging_enabled
 227
 228
 229 class AgingEnabledTimeProperty(dnsp.DnsProperty):
 230
 231     def __init__(self, next_cycle_hours=0):
 232         super(AgingEnabledTimeProperty, self).__init__()
 233         self.wDataLength = 1
 234         self.version = 1;
 235         self.id = dnsp.DSPROPERTY_ZONE_AGING_ENABLED_TIME
 236         self.data = next_cycle_hours
 237
 238
 239 def setup_dns_partitions(samdb, domainsid, domaindn, forestdn, configdn,
 240                          serverdn, fill_level):
 241     domainzone_dn = "DC=DomainDnsZones,%s" % domaindn
 242     forestzone_dn = "DC=ForestDnsZones,%s" % forestdn
 243     descriptor = get_dns_partition_descriptor(domainsid)
 244
 245     setup_add_ldif(samdb, setup_path("provision_dnszones_partitions.ldif"), {
 246         "ZONE_DN": domainzone_dn,
 247         "SECDESC"      : b64encode(descriptor)
 248         })
 249     if fill_level != FILL_SUBDOMAIN:
 250         setup_add_ldif(samdb, setup_path("provision_dnszones_partitions.ldif"), {
 251             "ZONE_DN": forestzone_dn,
 252             "SECDESC"      : b64encode(descriptor)
 253         })
 254
 255     domainzone_guid = get_domainguid(samdb, domainzone_dn)
 256     domainzone_guid = str(uuid.uuid4())
 257     domainzone_dns = ldb.Dn(samdb, domainzone_dn).canonical_ex_str().strip()
 258
 259     protected1_desc = get_domain_delete_protected1_descriptor(domainsid)
 260     protected2_desc = get_domain_delete_protected2_descriptor(domainsid)
 261     setup_add_ldif(samdb, setup_path("provision_dnszones_add.ldif"), {
 262         "ZONE_DN": domainzone_dn,
 263         "ZONE_GUID": domainzone_guid,
 264         "ZONE_DNS": domainzone_dns,
 265         "CONFIGDN": configdn,
 266         "SERVERDN": serverdn,
 267         "LOSTANDFOUND_DESCRIPTOR": b64encode(protected2_desc),
 268         "INFRASTRUCTURE_DESCRIPTOR": b64encode(protected1_desc),
 269         })
 270     setup_modify_ldif(samdb, setup_path("provision_dnszones_modify.ldif"), {
 271         "CONFIGDN": configdn,
 272         "SERVERDN": serverdn,
 273         "ZONE_DN": domainzone_dn,
 274     })
 275
 276     if fill_level != FILL_SUBDOMAIN:
 277         forestzone_guid = get_domainguid(samdb, forestzone_dn)
 278         forestzone_guid = str(uuid.uuid4())
 279         forestzone_dns = ldb.Dn(samdb, forestzone_dn).canonical_ex_str().strip()
 280
 281         setup_add_ldif(samdb, setup_path("provision_dnszones_add.ldif"), {
 282             "ZONE_DN": forestzone_dn,
 283             "ZONE_GUID": forestzone_guid,
 284             "ZONE_DNS": forestzone_dns,
 285             "CONFIGDN": configdn,
 286             "SERVERDN": serverdn,
 287             "LOSTANDFOUND_DESCRIPTOR": b64encode(protected2_desc),
 288             "INFRASTRUCTURE_DESCRIPTOR": b64encode(protected1_desc),
 289         })
 290         setup_modify_ldif(samdb, setup_path("provision_dnszones_modify.ldif"), {
 291             "CONFIGDN": configdn,
 292             "SERVERDN": serverdn,
 293             "ZONE_DN": forestzone_dn,
 294         })
 295
 296
 297 def add_dns_accounts(samdb, domaindn):
 298     setup_add_ldif(samdb, setup_path("provision_dns_accounts_add.ldif"), {
 299         "DOMAINDN": domaindn,
 300         })
 301
 302
 303 def add_dns_container(samdb, domaindn, prefix, domain_sid, dnsadmins_sid, forest=False):
 304     name_map = {'DnsAdmins': str(dnsadmins_sid)}
 305     if forest is True:
 306         sd_val = get_dns_forest_microsoft_dns_descriptor(domain_sid,
 307                                                          name_map=name_map)
 308     else:
 309         sd_val = get_dns_domain_microsoft_dns_descriptor(domain_sid,
 310                                                          name_map=name_map)
 311     # CN=MicrosoftDNS,<PREFIX>,<DOMAINDN>
 312     msg = ldb.Message(ldb.Dn(samdb, "CN=MicrosoftDNS,%s,%s" % (prefix, domaindn)))
 313     msg["objectClass"] = ["top", "container"]
 314     msg["nTSecurityDescriptor"] = ldb.MessageElement(sd_val, ldb.FLAG_MOD_ADD,
 315         "nTSecurityDescriptor")
 316     samdb.add(msg)
 317
 318
 319 def add_rootservers(samdb, domaindn, prefix):
 320     rootservers = {}
 321     rootservers["a.root-servers.net"] = "198.41.0.4"
 322     rootservers["b.root-servers.net"] = "192.228.79.201"
 323     rootservers["c.root-servers.net"] = "192.33.4.12"
 324     rootservers["d.root-servers.net"] = "128.8.10.90"
 325     rootservers["e.root-servers.net"] = "192.203.230.10"
 326     rootservers["f.root-servers.net"] = "192.5.5.241"
 327     rootservers["g.root-servers.net"] = "192.112.36.4"
 328     rootservers["h.root-servers.net"] = "128.63.2.53"
 329     rootservers["i.root-servers.net"] = "192.36.148.17"
 330     rootservers["j.root-servers.net"] = "192.58.128.30"
 331     rootservers["k.root-servers.net"] = "193.0.14.129"
 332     rootservers["l.root-servers.net"] = "199.7.83.42"
 333     rootservers["m.root-servers.net"] = "202.12.27.33"
 334
 335     rootservers_v6 = {}
 336     rootservers_v6["a.root-servers.net"] = "2001:503:ba3e::2:30"
 337     rootservers_v6["f.root-servers.net"] = "2001:500:2f::f"
 338     rootservers_v6["h.root-servers.net"] = "2001:500:1::803f:235"
 339     rootservers_v6["j.root-servers.net"] = "2001:503:c27::2:30"
 340     rootservers_v6["k.root-servers.net"] = "2001:7fd::1"
 341     rootservers_v6["m.root-servers.net"] = "2001:dc3::35"
 342
 343     container_dn = "DC=RootDNSServers,CN=MicrosoftDNS,%s,%s" % (prefix, domaindn)
 344
 345     # Add DC=RootDNSServers,CN=MicrosoftDNS,<PREFIX>,<DOMAINDN>
 346     msg = ldb.Message(ldb.Dn(samdb, container_dn))
 347     props = []
 348     props.append(ndr_pack(TypeProperty(zone_type=dnsp.DNS_ZONE_TYPE_CACHE)))
 349     props.append(ndr_pack(AllowUpdateProperty(allow_update=dnsp.DNS_ZONE_UPDATE_OFF)))
 350     props.append(ndr_pack(SecureTimeProperty()))
 351     props.append(ndr_pack(NorefreshIntervalProperty()))
 352     props.append(ndr_pack(RefreshIntervalProperty()))
 353     props.append(ndr_pack(AgingStateProperty()))
 354     props.append(ndr_pack(AgingEnabledTimeProperty()))
 355     msg["objectClass"] = ["top", "dnsZone"]
 356     msg["cn"] = ldb.MessageElement("Zone", ldb.FLAG_MOD_ADD, "cn")
 357     msg["dNSProperty"] = ldb.MessageElement(props, ldb.FLAG_MOD_ADD, "dNSProperty")
 358     samdb.add(msg)
 359
 360     # Add DC=@,DC=RootDNSServers,CN=MicrosoftDNS,<PREFIX>,<DOMAINDN>
 361     record = []
 362     for rserver in rootservers:
 363         record.append(ndr_pack(NSRecord(rserver, serial=0, ttl=0, rank=dnsp.DNS_RANK_ROOT_HINT)))
 364
 365     msg = ldb.Message(ldb.Dn(samdb, "DC=@,%s" % container_dn))
 366     msg["objectClass"] = ["top", "dnsNode"]
 367     msg["dnsRecord"] = ldb.MessageElement(record, ldb.FLAG_MOD_ADD, "dnsRecord")
 368     samdb.add(msg)
 369
 370     # Add DC=<rootserver>,DC=RootDNSServers,CN=MicrosoftDNS,<PREFIX>,<DOMAINDN>
 371     for rserver in rootservers:
 372         record = [ndr_pack(ARecord(rootservers[rserver], serial=0, ttl=0, rank=dnsp.DNS_RANK_ROOT_HINT))]
 373         # Add AAAA record as well (How does W2K* add IPv6 records?)
 374         #if rserver in rootservers_v6:
 375         #    record.append(ndr_pack(AAAARecord(rootservers_v6[rserver], serial=0, ttl=0)))
 376         msg = ldb.Message(ldb.Dn(samdb, "DC=%s,%s" % (rserver, container_dn)))
 377         msg["objectClass"] = ["top", "dnsNode"]
 378         msg["dnsRecord"] = ldb.MessageElement(record, ldb.FLAG_MOD_ADD, "dnsRecord")
 379         samdb.add(msg)
 380
 381 def add_at_record(samdb, container_dn, prefix, hostname, dnsdomain, hostip, hostip6):
 382
 383     fqdn_hostname = "%s.%s" % (hostname, dnsdomain)
 384
 385     at_records = []
 386
 387     # SOA record
 388     at_soa_record = SOARecord(fqdn_hostname, "hostmaster.%s" % dnsdomain)
 389     at_records.append(ndr_pack(at_soa_record))
 390
 391     # NS record
 392     at_ns_record = NSRecord(fqdn_hostname)
 393     at_records.append(ndr_pack(at_ns_record))
 394
 395     if hostip is not None:
 396         # A record
 397         at_a_record = ARecord(hostip)
 398         at_records.append(ndr_pack(at_a_record))
 399
 400     if hostip6 is not None:
 401         # AAAA record
 402         at_aaaa_record = AAAARecord(hostip6)
 403         at_records.append(ndr_pack(at_aaaa_record))
 404
 405     msg = ldb.Message(ldb.Dn(samdb, "DC=@,%s" % container_dn))
 406     msg["objectClass"] = ["top", "dnsNode"]
 407     msg["dnsRecord"] = ldb.MessageElement(at_records, ldb.FLAG_MOD_ADD, "dnsRecord")
 408     samdb.add(msg)
 409
 410
 411 def add_srv_record(samdb, container_dn, prefix, host, port):
 412     srv_record = SRVRecord(host, port)
 413     msg = ldb.Message(ldb.Dn(samdb, "%s,%s" % (prefix, container_dn)))
 414     msg["objectClass"] = ["top", "dnsNode"]
 415     msg["dnsRecord"] = ldb.MessageElement(ndr_pack(srv_record), ldb.FLAG_MOD_ADD, "dnsRecord")
 416     samdb.add(msg)
 417
 418
 419 def add_ns_record(samdb, container_dn, prefix, host):
 420     ns_record = NSRecord(host)
 421     msg = ldb.Message(ldb.Dn(samdb, "%s,%s" % (prefix, container_dn)))
 422     msg["objectClass"] = ["top", "dnsNode"]
 423     msg["dnsRecord"] = ldb.MessageElement(ndr_pack(ns_record), ldb.FLAG_MOD_ADD, "dnsRecord")
 424     samdb.add(msg)
 425
 426
 427 def add_ns_glue_record(samdb, container_dn, prefix, host):
 428     ns_record = NSRecord(host, rank=dnsp.DNS_RANK_NS_GLUE)
 429     msg = ldb.Message(ldb.Dn(samdb, "%s,%s" % (prefix, container_dn)))
 430     msg["objectClass"] = ["top", "dnsNode"]
 431     msg["dnsRecord"] = ldb.MessageElement(ndr_pack(ns_record), ldb.FLAG_MOD_ADD, "dnsRecord")
 432     samdb.add(msg)
 433
 434
 435 def add_cname_record(samdb, container_dn, prefix, host):
 436     cname_record = CNameRecord(host)
 437     msg = ldb.Message(ldb.Dn(samdb, "%s,%s" % (prefix, container_dn)))
 438     msg["objectClass"] = ["top", "dnsNode"]
 439     msg["dnsRecord"] = ldb.MessageElement(ndr_pack(cname_record), ldb.FLAG_MOD_ADD, "dnsRecord")
 440     samdb.add(msg)
 441
 442
 443 def add_host_record(samdb, container_dn, prefix, hostip, hostip6):
 444     host_records = []
 445     if hostip:
 446         a_record = ARecord(hostip)
 447         host_records.append(ndr_pack(a_record))
 448     if hostip6:
 449         aaaa_record = AAAARecord(hostip6)
 450         host_records.append(ndr_pack(aaaa_record))
 451     if host_records:
 452         msg = ldb.Message(ldb.Dn(samdb, "%s,%s" % (prefix, container_dn)))
 453         msg["objectClass"] = ["top", "dnsNode"]
 454         msg["dnsRecord"] = ldb.MessageElement(host_records, ldb.FLAG_MOD_ADD, "dnsRecord")
 455         samdb.add(msg)
 456
 457
 458 def add_domain_record(samdb, domaindn, prefix, dnsdomain, domainsid, dnsadmins_sid):
 459     # DC=<DNSDOMAIN>,CN=MicrosoftDNS,<PREFIX>,<DOMAINDN>
 460     sddl = "O:SYG:BAD:AI" \
 461     "(A;;RPWPCRCCDCLCLORCWOWDSDDTSW;;;DA)" \
 462     "(A;;CC;;;AU)" \
 463     "(A;;RPLCLORC;;;WD)" \
 464     "(A;;RPWPCRCCDCLCLORCWOWDSDDTSW;;;SY)" \
 465     "(A;CI;RPWPCRCCDCLCRCWOWDSDDTSW;;;ED)" \
 466     "(A;CIID;RPWPCRCCDCLCRCWOWDSDDTSW;;;%s)" \
 467     "(A;CIID;RPWPCRCCDCLCRCWOWDSDDTSW;;;ED)" \
 468     "(OA;CIID;RPWPCR;91e647de-d96f-4b70-9557-d63ff4f3ccd8;;PS)" \
 469     "(A;CIID;RPWPCRCCDCLCLORCWOWDSDDTSW;;;EA)" \
 470     "(A;CIID;LC;;;RU)" \
 471     "(A;CIID;RPWPCRCCLCLORCWOWDSDSW;;;BA)" \
 472     "S:AI" % dnsadmins_sid
 473     sec = security.descriptor.from_sddl(sddl, domainsid)
 474     props = []
 475     props.append(ndr_pack(TypeProperty()))
 476     props.append(ndr_pack(AllowUpdateProperty()))
 477     props.append(ndr_pack(SecureTimeProperty()))
 478     props.append(ndr_pack(NorefreshIntervalProperty(norefresh_interval=168)))
 479     props.append(ndr_pack(RefreshIntervalProperty(refresh_interval=168)))
 480     props.append(ndr_pack(AgingStateProperty()))
 481     props.append(ndr_pack(AgingEnabledTimeProperty()))
 482     msg = ldb.Message(ldb.Dn(samdb, "DC=%s,CN=MicrosoftDNS,%s,%s" % (dnsdomain, prefix, domaindn)))
 483     msg["objectClass"] = ["top", "dnsZone"]
 484     msg["ntSecurityDescriptor"] = ldb.MessageElement(ndr_pack(sec), ldb.FLAG_MOD_ADD,
 485         "nTSecurityDescriptor")
 486     msg["dNSProperty"] = ldb.MessageElement(props, ldb.FLAG_MOD_ADD, "dNSProperty")
 487     samdb.add(msg)
 488
 489
 490 def add_msdcs_record(samdb, forestdn, prefix, dnsforest):
 491     # DC=_msdcs.<DNSFOREST>,CN=MicrosoftDNS,<PREFIX>,<FORESTDN>
 492     msg = ldb.Message(ldb.Dn(samdb, "DC=_msdcs.%s,CN=MicrosoftDNS,%s,%s" %
 493                                     (dnsforest, prefix, forestdn)))
 494     msg["objectClass"] = ["top", "dnsZone"]
 495     samdb.add(msg)
 496
 497
 498 def add_dc_domain_records(samdb, domaindn, prefix, site, dnsdomain, hostname,
 499         hostip, hostip6):
 500
 501     fqdn_hostname = "%s.%s" % (hostname, dnsdomain)
 502
 503     # Set up domain container - DC=<DNSDOMAIN>,CN=MicrosoftDNS,<PREFIX>,<DOMAINDN>
 504     domain_container_dn = ldb.Dn(samdb, "DC=%s,CN=MicrosoftDNS,%s,%s" %
 505                                     (dnsdomain, prefix, domaindn))
 506
 507     # DC=@ record
 508     add_at_record(samdb, domain_container_dn, "DC=@", hostname, dnsdomain,
 509             hostip, hostip6)
 510
 511     # DC=<HOSTNAME> record
 512     add_host_record(samdb, domain_container_dn, "DC=%s" % hostname, hostip,
 513             hostip6)
 514
 515     # DC=_kerberos._tcp record
 516     add_srv_record(samdb, domain_container_dn, "DC=_kerberos._tcp",
 517             fqdn_hostname, 88)
 518
 519     # DC=_kerberos._tcp.<SITENAME>._sites record
 520     add_srv_record(samdb, domain_container_dn, "DC=_kerberos._tcp.%s._sites" %
 521             site, fqdn_hostname, 88)
 522
 523     # DC=_kerberos._udp record
 524     add_srv_record(samdb, domain_container_dn, "DC=_kerberos._udp",
 525             fqdn_hostname, 88)
 526
 527     # DC=_kpasswd._tcp record
 528     add_srv_record(samdb, domain_container_dn, "DC=_kpasswd._tcp",
 529             fqdn_hostname, 464)
 530
 531     # DC=_kpasswd._udp record
 532     add_srv_record(samdb, domain_container_dn, "DC=_kpasswd._udp",
 533             fqdn_hostname, 464)
 534
 535     # DC=_ldap._tcp record
 536     add_srv_record(samdb, domain_container_dn, "DC=_ldap._tcp", fqdn_hostname,
 537             389)
 538
 539     # DC=_ldap._tcp.<SITENAME>._sites record
 540     add_srv_record(samdb, domain_container_dn, "DC=_ldap._tcp.%s._sites" %
 541             site, fqdn_hostname, 389)
 542
 543     # FIXME: The number of SRV records depend on the various roles this DC has.
 544     #        _gc and _msdcs records are added if the we are the forest dc and not subdomain dc
 545     #
 546     # Assumption: current DC is GC and add all the entries
 547
 548     # DC=_gc._tcp record
 549     add_srv_record(samdb, domain_container_dn, "DC=_gc._tcp", fqdn_hostname,
 550             3268)
 551
 552     # DC=_gc._tcp.<SITENAME>,_sites record
 553     add_srv_record(samdb, domain_container_dn, "DC=_gc._tcp.%s._sites" % site,
 554             fqdn_hostname, 3268)
 555
 556     # DC=_msdcs record
 557     add_ns_glue_record(samdb, domain_container_dn, "DC=_msdcs", fqdn_hostname)
 558
 559     # FIXME: Following entries are added only if DomainDnsZones and ForestDnsZones partitions
 560     #        are created
 561     #
 562     # Assumption: Additional entries won't hurt on os_level = 2000
 563
 564     # DC=_ldap._tcp.<SITENAME>._sites.DomainDnsZones
 565     add_srv_record(samdb, domain_container_dn,
 566             "DC=_ldap._tcp.%s._sites.DomainDnsZones" % site, fqdn_hostname,
 567             389)
 568
 569     # DC=_ldap._tcp.<SITENAME>._sites.ForestDnsZones
 570     add_srv_record(samdb, domain_container_dn,
 571             "DC=_ldap._tcp.%s._sites.ForestDnsZones" % site, fqdn_hostname,
 572             389)
 573
 574     # DC=_ldap._tcp.DomainDnsZones
 575     add_srv_record(samdb, domain_container_dn, "DC=_ldap._tcp.DomainDnsZones",
 576                     fqdn_hostname, 389)
 577
 578     # DC=_ldap._tcp.ForestDnsZones
 579     add_srv_record(samdb, domain_container_dn, "DC=_ldap._tcp.ForestDnsZones",
 580                     fqdn_hostname, 389)
 581
 582     # DC=DomainDnsZones
 583     add_host_record(samdb, domain_container_dn, "DC=DomainDnsZones", hostip,
 584             hostip6)
 585
 586     # DC=ForestDnsZones
 587     add_host_record(samdb, domain_container_dn, "DC=ForestDnsZones", hostip,
 588             hostip6)
 589
 590
 591 def add_dc_msdcs_records(samdb, forestdn, prefix, site, dnsforest, hostname,
 592                             hostip, hostip6, domainguid, ntdsguid):
 593
 594     fqdn_hostname = "%s.%s" % (hostname, dnsforest)
 595
 596     # Set up forest container - DC=<DNSDOMAIN>,CN=MicrosoftDNS,<PREFIX>,<DOMAINDN>
 597     forest_container_dn = ldb.Dn(samdb, "DC=_msdcs.%s,CN=MicrosoftDNS,%s,%s" %
 598                                     (dnsforest, prefix, forestdn))
 599
 600     # DC=@ record
 601     add_at_record(samdb, forest_container_dn, "DC=@", hostname, dnsforest,
 602             None, None)
 603
 604     # DC=_kerberos._tcp.dc record
 605     add_srv_record(samdb, forest_container_dn, "DC=_kerberos._tcp.dc",
 606             fqdn_hostname, 88)
 607
 608     # DC=_kerberos._tcp.<SITENAME>._sites.dc record
 609     add_srv_record(samdb, forest_container_dn,
 610             "DC=_kerberos._tcp.%s._sites.dc" % site, fqdn_hostname, 88)
 611
 612     # DC=_ldap._tcp.dc record
 613     add_srv_record(samdb, forest_container_dn, "DC=_ldap._tcp.dc",
 614             fqdn_hostname, 389)
 615
 616     # DC=_ldap._tcp.<SITENAME>._sites.dc record
 617     add_srv_record(samdb, forest_container_dn, "DC=_ldap._tcp.%s._sites.dc" %
 618             site, fqdn_hostname, 389)
 619
 620     # DC=_ldap._tcp.<SITENAME>._sites.gc record
 621     add_srv_record(samdb, forest_container_dn, "DC=_ldap._tcp.%s._sites.gc" %
 622             site, fqdn_hostname, 3268)
 623
 624     # DC=_ldap._tcp.gc record
 625     add_srv_record(samdb, forest_container_dn, "DC=_ldap._tcp.gc",
 626             fqdn_hostname, 3268)
 627
 628     # DC=_ldap._tcp.pdc record
 629     add_srv_record(samdb, forest_container_dn, "DC=_ldap._tcp.pdc",
 630             fqdn_hostname, 389)
 631
 632     # DC=gc record
 633     add_host_record(samdb, forest_container_dn, "DC=gc", hostip, hostip6)
 634
 635     # DC=_ldap._tcp.<DOMAINGUID>.domains record
 636     add_srv_record(samdb, forest_container_dn,
 637             "DC=_ldap._tcp.%s.domains" % domainguid, fqdn_hostname, 389)
 638
 639     # DC=<NTDSGUID>
 640     add_cname_record(samdb, forest_container_dn, "DC=%s" % ntdsguid,
 641             fqdn_hostname)
 642
 643
 644 def secretsdb_setup_dns(secretsdb, names, private_dir, realm,
 645                         dnsdomain, dns_keytab_path, dnspass, key_version_number):
 646     """Add DNS specific bits to a secrets database.
 647
 648     :param secretsdb: Ldb Handle to the secrets database
 649     :param names: Names shortcut
 650     :param machinepass: Machine password
 651     """
 652     try:
 653         os.unlink(os.path.join(private_dir, dns_keytab_path))
 654     except OSError:
 655         pass
 656
 657     if key_version_number is None:
 658         key_version_number = 1
 659
 660     setup_ldb(secretsdb, setup_path("secrets_dns.ldif"), {
 661             "REALM": realm,
 662             "DNSDOMAIN": dnsdomain,
 663             "DNS_KEYTAB": dns_keytab_path,
 664             "DNSPASS_B64": b64encode(dnspass),
 665             "KEY_VERSION_NUMBER": str(key_version_number),
 666             "HOSTNAME": names.hostname,
 667             "DNSNAME" : '%s.%s' % (
 668                 names.netbiosname.lower(), names.dnsdomain.lower())
 669             })
 670
 671
 672 def create_dns_dir(logger, paths):
 673     """Write out a DNS zone file, from the info in the current database.
 674
 675     :param logger: Logger object
 676     :param paths: paths object
 677     """
 678     dns_dir = os.path.dirname(paths.dns)
 679
 680     try:
 681         shutil.rmtree(dns_dir, True)
 682     except OSError:
 683         pass
 684
 685     os.mkdir(dns_dir, 0770)
 686
 687     if paths.bind_gid is not None:
 688         try:
 689             os.chown(dns_dir, -1, paths.bind_gid)
 690             # chmod needed to cope with umask
 691             os.chmod(dns_dir, 0770)
 692         except OSError:
 693             if not os.environ.has_key('SAMBA_SELFTEST'):
 694                 logger.error("Failed to chown %s to bind gid %u" % (
 695                     dns_dir, paths.bind_gid))
 696
 697
 698 def create_zone_file(lp, logger, paths, targetdir, dnsdomain,
 699                      hostip, hostip6, hostname, realm, domainguid,
 700                      ntdsguid, site):
 701     """Write out a DNS zone file, from the info in the current database.
 702
 703     :param paths: paths object
 704     :param dnsdomain: DNS Domain name
 705     :param domaindn: DN of the Domain
 706     :param hostip: Local IPv4 IP
 707     :param hostip6: Local IPv6 IP
 708     :param hostname: Local hostname
 709     :param realm: Realm name
 710     :param domainguid: GUID of the domain.
 711     :param ntdsguid: GUID of the hosts nTDSDSA record.
 712     """
 713     assert isinstance(domainguid, str)
 714
 715     if hostip6 is not None:
 716         hostip6_base_line = "            IN AAAA    " + hostip6
 717         hostip6_host_line = hostname + "        IN AAAA    " + hostip6
 718         gc_msdcs_ip6_line = "gc._msdcs               IN AAAA    " + hostip6
 719     else:
 720         hostip6_base_line = ""
 721         hostip6_host_line = ""
 722         gc_msdcs_ip6_line = ""
 723
 724     if hostip is not None:
 725         hostip_base_line = "            IN A    " + hostip
 726         hostip_host_line = hostname + "        IN A    " + hostip
 727         gc_msdcs_ip_line = "gc._msdcs               IN A    " + hostip
 728     else:
 729         hostip_base_line = ""
 730         hostip_host_line = ""
 731         gc_msdcs_ip_line = ""
 732
 733     # we need to freeze the zone while we update the contents
 734     if targetdir is None:
 735         rndc = ' '.join(lp.get("rndc command"))
 736         os.system(rndc + " freeze " + lp.get("realm"))
 737
 738     setup_file(setup_path("provision.zone"), paths.dns, {
 739             "HOSTNAME": hostname,
 740             "DNSDOMAIN": dnsdomain,
 741             "REALM": realm,
 742             "HOSTIP_BASE_LINE": hostip_base_line,
 743             "HOSTIP_HOST_LINE": hostip_host_line,
 744             "DOMAINGUID": domainguid,
 745             "DATESTRING": time.strftime("%Y%m%d%H"),
 746             "DEFAULTSITE": site,
 747             "NTDSGUID": ntdsguid,
 748             "HOSTIP6_BASE_LINE": hostip6_base_line,
 749             "HOSTIP6_HOST_LINE": hostip6_host_line,
 750             "GC_MSDCS_IP_LINE": gc_msdcs_ip_line,
 751             "GC_MSDCS_IP6_LINE": gc_msdcs_ip6_line,
 752         })
 753
 754     if paths.bind_gid is not None:
 755         try:
 756             os.chown(paths.dns, -1, paths.bind_gid)
 757             # chmod needed to cope with umask
 758             os.chmod(paths.dns, 0664)
 759         except OSError:
 760             if not os.environ.has_key('SAMBA_SELFTEST'):
 761                 logger.error("Failed to chown %s to bind gid %u" % (
 762                     paths.dns, paths.bind_gid))
 763
 764     if targetdir is None:
 765         os.system(rndc + " unfreeze " + lp.get("realm"))
 766
 767
 768 def create_samdb_copy(samdb, logger, paths, names, domainsid, domainguid):
 769     """Create a copy of samdb and give write permissions to named for dns partitions
 770     """
 771     private_dir = paths.private_dir
 772     samldb_dir = os.path.join(private_dir, "sam.ldb.d")
 773     dns_dir = os.path.dirname(paths.dns)
 774     dns_samldb_dir = os.path.join(dns_dir, "sam.ldb.d")
 775
 776     # Find the partitions and corresponding filenames
 777     partfile = {}
 778     res = samdb.search(base="@PARTITION", scope=ldb.SCOPE_BASE, attrs=["partition"])
 779     for tmp in res[0]["partition"]:
 780         (nc, fname) = tmp.split(':')
 781         partfile[nc.upper()] = fname
 782
 783     # Create empty domain partition
 784     domaindn = names.domaindn.upper()
 785     domainpart_file = os.path.join(dns_dir, partfile[domaindn])
 786     try:
 787         os.mkdir(dns_samldb_dir)
 788         file(domainpart_file, 'w').close()
 789
 790         # Fill the basedn and @OPTION records in domain partition
 791         dom_ldb = samba.Ldb(domainpart_file)
 792         domainguid_line = "objectGUID: %s\n-" % domainguid
 793         descr = b64encode(get_domain_descriptor(domainsid))
 794         setup_add_ldif(dom_ldb, setup_path("provision_basedn.ldif"), {
 795             "DOMAINDN" : names.domaindn,
 796             "DOMAINGUID" : domainguid_line,
 797             "DOMAINSID" : str(domainsid),
 798             "DESCRIPTOR" : descr})
 799         setup_add_ldif(dom_ldb,
 800             setup_path("provision_basedn_options.ldif"), None)
 801     except:
 802         logger.error(
 803             "Failed to setup database for BIND, AD based DNS cannot be used")
 804         raise
 805
 806     # This line is critical to the security of the whole scheme.
 807     # We assume there is no secret data in the (to be left out of
 808     # date and essentially read-only) config, schema and metadata partitions.
 809     #
 810     # Only the stub of the domain partition is created above.
 811     #
 812     # That way, things like the krbtgt key do not leak.
 813     del partfile[domaindn]
 814
 815     # Link dns partitions and metadata
 816     domainzonedn = "DC=DOMAINDNSZONES,%s" % names.domaindn.upper()
 817     forestzonedn = "DC=FORESTDNSZONES,%s" % names.rootdn.upper()
 818
 819     domainzone_file = partfile[domainzonedn]
 820     forestzone_file = partfile.get(forestzonedn)
 821
 822     metadata_file = "metadata.tdb"
 823     try:
 824         os.link(os.path.join(samldb_dir, metadata_file),
 825             os.path.join(dns_samldb_dir, metadata_file))
 826         os.link(os.path.join(private_dir, domainzone_file),
 827             os.path.join(dns_dir, domainzone_file))
 828         if forestzone_file:
 829             os.link(os.path.join(private_dir, forestzone_file),
 830                     os.path.join(dns_dir, forestzone_file))
 831     except OSError:
 832         logger.error(
 833             "Failed to setup database for BIND, AD based DNS cannot be used")
 834         raise
 835     del partfile[domainzonedn]
 836     if forestzone_file:
 837         del partfile[forestzonedn]
 838
 839     # Copy root, config, schema partitions (and any other if any)
 840     # Since samdb is open in the current process, copy them in a child process
 841     try:
 842         tdb_copy(os.path.join(private_dir, "sam.ldb"),
 843                  os.path.join(dns_dir, "sam.ldb"))
 844         for nc in partfile:
 845             pfile = partfile[nc]
 846             tdb_copy(os.path.join(private_dir, pfile),
 847                      os.path.join(dns_dir, pfile))
 848     except:
 849         logger.error(
 850             "Failed to setup database for BIND, AD based DNS cannot be used")
 851         raise
 852
 853     # Give bind read/write permissions dns partitions
 854     if paths.bind_gid is not None:
 855         try:
 856             os.chown(samldb_dir, -1, paths.bind_gid)
 857             os.chmod(samldb_dir, 0750)
 858
 859             for dirname, dirs, files in os.walk(dns_dir):
 860                 for d in dirs:
 861                     dpath = os.path.join(dirname, d)
 862                     os.chown(dpath, -1, paths.bind_gid)
 863                     os.chmod(dpath, 0770)
 864                 for f in files:
 865                     if f.endswith('.ldb') or f.endswith('.tdb'):
 866                         fpath = os.path.join(dirname, f)
 867                         os.chown(fpath, -1, paths.bind_gid)
 868                         os.chmod(fpath, 0660)
 869         except OSError:
 870             if not os.environ.has_key('SAMBA_SELFTEST'):
 871                 logger.error(
 872                     "Failed to set permissions to sam.ldb* files, fix manually")
 873     else:
 874         if not os.environ.has_key('SAMBA_SELFTEST'):
 875             logger.warning("""Unable to find group id for BIND,
 876                 set permissions to sam.ldb* files manually""")
 877
 878
 879 def create_dns_update_list(lp, logger, paths):
 880     """Write out a dns_update_list file"""
 881     # note that we use no variable substitution on this file
 882     # the substitution is done at runtime by samba_dnsupdate, samba_spnupdate
 883     setup_file(setup_path("dns_update_list"), paths.dns_update_list, None)
 884     setup_file(setup_path("spn_update_list"), paths.spn_update_list, None)
 885
 886
 887 def create_named_conf(paths, realm, dnsdomain, dns_backend, logger):
 888     """Write out a file containing zone statements suitable for inclusion in a
 889     named.conf file (including GSS-TSIG configuration).
 890
 891     :param paths: all paths
 892     :param realm: Realm name
 893     :param dnsdomain: DNS Domain name
 894     :param dns_backend: DNS backend type
 895     :param keytab_name: File name of DNS keytab file
 896     :param logger: Logger object
 897     """
 898
 899     # TODO: This really should have been done as a top level import.
 900     # It is done here to avoid a depencency loop.  That is, we move
 901     # ProvisioningError to another file, and have all the provision
 902     # scripts import it from there.
 903
 904     from samba.provision import ProvisioningError
 905
 906     if dns_backend == "BIND9_FLATFILE":
 907         setup_file(setup_path("named.conf"), paths.namedconf, {
 908                     "DNSDOMAIN": dnsdomain,
 909                     "REALM": realm,
 910                     "ZONE_FILE": paths.dns,
 911                     "REALM_WC": "*." + ".".join(realm.split(".")[1:]),
 912                     "NAMED_CONF": paths.namedconf,
 913                     "NAMED_CONF_UPDATE": paths.namedconf_update
 914                     })
 915
 916         setup_file(setup_path("named.conf.update"), paths.namedconf_update)
 917
 918     elif dns_backend == "BIND9_DLZ":
 919         bind_info = subprocess.Popen(['named -V'], shell=True,
 920                                      stdout=subprocess.PIPE,
 921                                      stderr=subprocess.STDOUT,
 922                                      cwd='.').communicate()[0]
 923         bind9_8 = '#'
 924         bind9_9 = '#'
 925         bind9_10 = '#'
 926         if bind_info.upper().find('BIND 9.8') != -1:
 927             bind9_8 = ''
 928         elif bind_info.upper().find('BIND 9.9') != -1:
 929             bind9_9 = ''
 930         elif bind_info.upper().find('BIND 9.10') != -1:
 931             bind9_10 = ''
 932         elif bind_info.upper().find('BIND 9.7') != -1:
 933             raise ProvisioningError("DLZ option incompatible with BIND 9.7.")
 934         else:
 935             logger.warning("BIND version unknown, please modify %s manually." % paths.namedconf)
 936         setup_file(setup_path("named.conf.dlz"), paths.namedconf, {
 937                     "NAMED_CONF": paths.namedconf,
 938                     "MODULESDIR" : samba.param.modules_dir(),
 939                     "BIND9_8" : bind9_8,
 940                     "BIND9_9" : bind9_9,
 941                     "BIND9_10" : bind9_10
 942                     })
 943
 944
 945 def create_named_txt(path, realm, dnsdomain, dnsname, private_dir,
 946     keytab_name):
 947     """Write out a file containing zone statements suitable for inclusion in a
 948     named.conf file (including GSS-TSIG configuration).
 949
 950     :param path: Path of the new named.conf file.
 951     :param realm: Realm name
 952     :param dnsdomain: DNS Domain name
 953     :param private_dir: Path to private directory
 954     :param keytab_name: File name of DNS keytab file
 955     """
 956     setup_file(setup_path("named.txt"), path, {
 957             "DNSDOMAIN": dnsdomain,
 958             "DNSNAME" : dnsname,
 959             "REALM": realm,
 960             "DNS_KEYTAB": keytab_name,
 961             "DNS_KEYTAB_ABS": os.path.join(private_dir, keytab_name),
 962             "PRIVATE_DIR": private_dir
 963         })
 964
 965
 966 def is_valid_dns_backend(dns_backend):
 967     return dns_backend in ("BIND9_FLATFILE", "BIND9_DLZ", "SAMBA_INTERNAL", "NONE")
 968
 969
 970 def is_valid_os_level(os_level):
 971     return DS_DOMAIN_FUNCTION_2000 <= os_level <= DS_DOMAIN_FUNCTION_2012_R2
 972
 973
 974 def create_dns_legacy(samdb, domainsid, forestdn, dnsadmins_sid):
 975     # Set up MicrosoftDNS container
 976     add_dns_container(samdb, forestdn, "CN=System", domainsid, dnsadmins_sid)
 977     # Add root servers
 978     add_rootservers(samdb, forestdn, "CN=System")
 979
 980
 981 def fill_dns_data_legacy(samdb, domainsid, forestdn, dnsdomain, site, hostname,
 982                          hostip, hostip6, dnsadmins_sid):
 983     # Add domain record
 984     add_domain_record(samdb, forestdn, "CN=System", dnsdomain, domainsid,
 985                       dnsadmins_sid)
 986
 987     # Add DNS records for a DC in domain
 988     add_dc_domain_records(samdb, forestdn, "CN=System", site, dnsdomain,
 989                           hostname, hostip, hostip6)
 990
 991
 992 def create_dns_partitions(samdb, domainsid, names, domaindn, forestdn,
 993                           dnsadmins_sid, fill_level):
 994     # Set up additional partitions (DomainDnsZones, ForstDnsZones)
 995     setup_dns_partitions(samdb, domainsid, domaindn, forestdn,
 996                         names.configdn, names.serverdn, fill_level)
 997
 998     # Set up MicrosoftDNS containers
 999     add_dns_container(samdb, domaindn, "DC=DomainDnsZones", domainsid,
1000                       dnsadmins_sid)
1001     if fill_level != FILL_SUBDOMAIN:
1002         add_dns_container(samdb, forestdn, "DC=ForestDnsZones", domainsid,
1003                           dnsadmins_sid, forest=True)
1004
1005
1006 def fill_dns_data_partitions(samdb, domainsid, site, domaindn, forestdn,
1007                              dnsdomain, dnsforest, hostname, hostip, hostip6,
1008                              domainguid, ntdsguid, dnsadmins_sid, autofill=True,
1009                              fill_level=FILL_FULL):
1010     """Fill data in various AD partitions
1011
1012     :param samdb: LDB object connected to sam.ldb file
1013     :param domainsid: Domain SID (as dom_sid object)
1014     :param site: Site name to create hostnames in
1015     :param domaindn: DN of the domain
1016     :param forestdn: DN of the forest
1017     :param dnsdomain: DNS name of the domain
1018     :param dnsforest: DNS name of the forest
1019     :param hostname: Host name of this DC
1020     :param hostip: IPv4 addresses
1021     :param hostip6: IPv6 addresses
1022     :param domainguid: Domain GUID
1023     :param ntdsguid: NTDS GUID
1024     :param dnsadmins_sid: SID for DnsAdmins group
1025     :param autofill: Create DNS records (using fixed template)
1026     """
1027
1028     ##### Set up DC=DomainDnsZones,<DOMAINDN>
1029     # Add rootserver records
1030     add_rootservers(samdb, domaindn, "DC=DomainDnsZones")
1031
1032     # Add domain record
1033     add_domain_record(samdb, domaindn, "DC=DomainDnsZones", dnsdomain,
1034                       domainsid, dnsadmins_sid)
1035
1036     # Add DNS records for a DC in domain
1037     if autofill:
1038         add_dc_domain_records(samdb, domaindn, "DC=DomainDnsZones", site,
1039                               dnsdomain, hostname, hostip, hostip6)
1040
1041     if fill_level != FILL_SUBDOMAIN:
1042         ##### Set up DC=ForestDnsZones,<FORESTDN>
1043         # Add _msdcs record
1044         add_msdcs_record(samdb, forestdn, "DC=ForestDnsZones", dnsforest)
1045
1046         # Add DNS records for a DC in forest
1047         if autofill:
1048             add_dc_msdcs_records(samdb, forestdn, "DC=ForestDnsZones", site,
1049                                  dnsforest, hostname, hostip, hostip6,
1050                                  domainguid, ntdsguid)
1051
1052
1053 def setup_ad_dns(samdb, secretsdb, names, paths, lp, logger,
1054         dns_backend, os_level, dnspass=None, hostip=None, hostip6=None,
1055         targetdir=None, fill_level=FILL_FULL):
1056     """Provision DNS information (assuming GC role)
1057
1058     :param samdb: LDB object connected to sam.ldb file
1059     :param secretsdb: LDB object connected to secrets.ldb file
1060     :param names: Names shortcut
1061     :param paths: Paths shortcut
1062     :param lp: Loadparm object
1063     :param logger: Logger object
1064     :param dns_backend: Type of DNS backend
1065     :param os_level: Functional level (treated as os level)
1066     :param dnspass: Password for bind's DNS account
1067     :param hostip: IPv4 address
1068     :param hostip6: IPv6 address
1069     :param targetdir: Target directory for creating DNS-related files for BIND9
1070     """
1071
1072     if not is_valid_dns_backend(dns_backend):
1073         raise Exception("Invalid dns backend: %r" % dns_backend)
1074
1075     if not is_valid_os_level(os_level):
1076         raise Exception("Invalid os level: %r" % os_level)
1077
1078     if dns_backend == "NONE":
1079         logger.info("No DNS backend set, not configuring DNS")
1080         return
1081
1082     # Add dns accounts (DnsAdmins, DnsUpdateProxy) in domain
1083     logger.info("Adding DNS accounts")
1084     add_dns_accounts(samdb, names.domaindn)
1085
1086     # If dns_backend is BIND9_FLATFILE
1087     #   Populate only CN=MicrosoftDNS,CN=System,<DOMAINDN>
1088     #
1089     # If dns_backend is SAMBA_INTERNAL or BIND9_DLZ
1090     #   Populate DNS partitions
1091
1092     # If os_level < 2003 (DS_DOMAIN_FUNCTION_2000)
1093     #   All dns records are in CN=MicrosoftDNS,CN=System,<DOMAINDN>
1094     #
1095     # If os_level >= 2003 (DS_DOMAIN_FUNCTION_2003, DS_DOMAIN_FUNCTION_2008,
1096     #                        DS_DOMAIN_FUNCTION_2008_R2)
1097     #   Root server records are in CN=MicrosoftDNS,CN=System,<DOMAINDN>
1098     #   Domain records are in CN=MicrosoftDNS,CN=System,<DOMAINDN>
1099     #   Domain records are in CN=MicrosoftDNS,DC=DomainDnsZones,<DOMAINDN>
1100     #   Forest records are in CN=MicrosoftDNS,DC=ForestDnsZones,<FORESTDN>
1101     domaindn = names.domaindn
1102     forestdn = samdb.get_root_basedn().get_linearized()
1103
1104     dnsdomain = names.dnsdomain.lower()
1105     dnsforest = dnsdomain
1106
1107     site = names.sitename
1108
1109     hostname = names.netbiosname.lower()
1110
1111     dnsadmins_sid = get_dnsadmins_sid(samdb, domaindn)
1112     domainguid = get_domainguid(samdb, domaindn)
1113
1114     samdb.transaction_start()
1115     try:
1116         # Create CN=System
1117         logger.info("Creating CN=MicrosoftDNS,CN=System,%s" % domaindn)
1118         create_dns_legacy(samdb, names.domainsid, domaindn, dnsadmins_sid)
1119
1120         if os_level == DS_DOMAIN_FUNCTION_2000:
1121             # Populating legacy dns
1122             logger.info("Populating CN=MicrosoftDNS,CN=System,%s" % domaindn)
1123             fill_dns_data_legacy(samdb, names.domainsid, domaindn, dnsdomain, site,
1124                                  hostname, hostip, hostip6, dnsadmins_sid)
1125
1126         elif dns_backend in ("SAMBA_INTERNAL", "BIND9_DLZ") and \
1127                 os_level >= DS_DOMAIN_FUNCTION_2003:
1128
1129             # Create DNS partitions
1130             logger.info("Creating DomainDnsZones and ForestDnsZones partitions")
1131             create_dns_partitions(samdb, names.domainsid, names, domaindn, forestdn,
1132                                   dnsadmins_sid, fill_level)
1133
1134             # Populating dns partitions
1135             logger.info("Populating DomainDnsZones and ForestDnsZones partitions")
1136             fill_dns_data_partitions(samdb, names.domainsid, site, domaindn, forestdn,
1137                                      dnsdomain, dnsforest, hostname, hostip, hostip6,
1138                                      domainguid, names.ntdsguid, dnsadmins_sid,
1139                                      fill_level=fill_level)
1140
1141     except:
1142         samdb.transaction_cancel()
1143         raise
1144     else:
1145         samdb.transaction_commit()
1146
1147     if dns_backend.startswith("BIND9_"):
1148         setup_bind9_dns(samdb, secretsdb, names, paths, lp, logger,
1149                         dns_backend, os_level, site=site, dnspass=dnspass, hostip=hostip,
1150                         hostip6=hostip6, targetdir=targetdir)
1151
1152
1153 def setup_bind9_dns(samdb, secretsdb, names, paths, lp, logger,
1154         dns_backend, os_level, site=None, dnspass=None, hostip=None,
1155         hostip6=None, targetdir=None, key_version_number=None):
1156     """Provision DNS information (assuming BIND9 backend in DC role)
1157
1158     :param samdb: LDB object connected to sam.ldb file
1159     :param secretsdb: LDB object connected to secrets.ldb file
1160     :param names: Names shortcut
1161     :param paths: Paths shortcut
1162     :param lp: Loadparm object
1163     :param logger: Logger object
1164     :param dns_backend: Type of DNS backend
1165     :param os_level: Functional level (treated as os level)
1166     :param site: Site to create hostnames in
1167     :param dnspass: Password for bind's DNS account
1168     :param hostip: IPv4 address
1169     :param hostip6: IPv6 address
1170     :param targetdir: Target directory for creating DNS-related files for BIND9
1171     """
1172
1173     if (not is_valid_dns_backend(dns_backend) or
1174         not dns_backend.startswith("BIND9_")):
1175         raise Exception("Invalid dns backend: %r" % dns_backend)
1176
1177     if not is_valid_os_level(os_level):
1178         raise Exception("Invalid os level: %r" % os_level)
1179
1180     domaindn = names.domaindn
1181
1182     domainguid = get_domainguid(samdb, domaindn)
1183
1184     secretsdb_setup_dns(secretsdb, names,
1185                         paths.private_dir, realm=names.realm,
1186                         dnsdomain=names.dnsdomain,
1187                         dns_keytab_path=paths.dns_keytab, dnspass=dnspass,
1188                         key_version_number=key_version_number)
1189
1190     dns_keytab_path = os.path.join(paths.private_dir, paths.dns_keytab)
1191     if os.path.isfile(dns_keytab_path) and paths.bind_gid is not None:
1192         try:
1193             os.chmod(dns_keytab_path, 0640)
1194             os.chown(dns_keytab_path, -1, paths.bind_gid)
1195         except OSError:
1196             if not os.environ.has_key('SAMBA_SELFTEST'):
1197                 logger.info("Failed to chown %s to bind gid %u",
1198                             dns_keytab_path, paths.bind_gid)
1199
1200     create_dns_dir(logger, paths)
1201
1202     if dns_backend == "BIND9_FLATFILE":
1203         create_zone_file(lp, logger, paths, targetdir, site=site,
1204                          dnsdomain=names.dnsdomain, hostip=hostip,
1205                          hostip6=hostip6, hostname=names.hostname,
1206                          realm=names.realm, domainguid=domainguid,
1207                          ntdsguid=names.ntdsguid)
1208
1209     if dns_backend == "BIND9_DLZ" and os_level >= DS_DOMAIN_FUNCTION_2003:
1210         create_samdb_copy(samdb, logger, paths, names, names.domainsid, domainguid)
1211
1212     create_named_conf(paths, realm=names.realm,
1213                       dnsdomain=names.dnsdomain, dns_backend=dns_backend,
1214                       logger=logger)
1215
1216     create_named_txt(paths.namedtxt,
1217                      realm=names.realm, dnsdomain=names.dnsdomain,
1218                      dnsname = "%s.%s" % (names.hostname, names.dnsdomain),
1219                      private_dir=paths.private_dir,
1220                      keytab_name=paths.dns_keytab)
1221     logger.info("See %s for an example configuration include file for BIND",
1222                 paths.namedconf)
1223     logger.info("and %s for further documentation required for secure DNS "
1224                 "updates", paths.namedtxt)