source4/scripting/bin/upgradeprovision

   1 #!/usr/bin/env python
   2 # vim: expandtab
   3 #
   4 # Copyright (C) Matthieu Patou <mat@matws.net> 2009 - 2010
   5 #
   6 # Based on provision a Samba4 server by
   7 # Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2007-2008
   8 # Copyright (C) Andrew Bartlett <abartlet@samba.org> 2008
   9 #
  10 #
  11 # This program is free software; you can redistribute it and/or modify
  12 # it under the terms of the GNU General Public License as published by
  13 # the Free Software Foundation; either version 3 of the License, or
  14 # (at your option) any later version.
  15 #
  16 # This program is distributed in the hope that it will be useful,
  17 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 # GNU General Public License for more details.
  20 #
  21 # You should have received a copy of the GNU General Public License
  22 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23
  24
  25 import logging
  26 import optparse
  27 import os
  28 import shutil
  29 import sys
  30 import tempfile
  31 import re
  32 import traceback
  33 # Allow to run from s4 source directory (without installing samba)
  34 sys.path.insert(0, "bin/python")
  35
  36 import ldb
  37 import samba
  38 import samba.getopt as options
  39
  40 from base64 import b64encode
  41 from samba.credentials import DONT_USE_KERBEROS
  42 from samba.auth import system_session, admin_session
  43 from ldb import (SCOPE_SUBTREE, SCOPE_BASE,
  44                 FLAG_MOD_REPLACE, FLAG_MOD_ADD, FLAG_MOD_DELETE,
  45                 MessageElement, Message, Dn)
  46 from samba import param, dsdb, Ldb
  47 from samba.provision import (find_setup_dir, get_domain_descriptor,
  48                             get_config_descriptor,
  49                             ProvisioningError, get_last_provision_usn,
  50                             get_max_usn, update_provision_usn)
  51 from samba.schema import get_linked_attributes, Schema, get_schema_descriptor
  52 from samba.dcerpc import security, drsblobs, xattr
  53 from samba.ndr import ndr_unpack
  54 from samba.upgradehelpers import (dn_sort, get_paths, newprovision,
  55                                  find_provision_key_parameters, get_ldbs,
  56                                  usn_in_range, identic_rename, get_diff_sddls,
  57                                  update_secrets, CHANGE, ERROR, SIMPLE,
  58                                  CHANGEALL, GUESS, CHANGESD, PROVISION,
  59                                  updateOEMInfo, getOEMInfo, update_gpo,
  60                                  delta_update_basesamdb, update_policyids,
  61                                  update_machine_account_password,
  62                                  search_constructed_attrs_stored,
  63                                  int64range2str,
  64                                  increment_calculated_keyversion_number)
  65
  66 replace=2**FLAG_MOD_REPLACE
  67 add=2**FLAG_MOD_ADD
  68 delete=2**FLAG_MOD_DELETE
  69 never=0
  70
  71
  72 # Will be modified during provision to tell if default sd has been modified
  73 # somehow ...
  74
  75 #Errors are always logged
  76
  77 __docformat__ = "restructuredText"
  78
  79 # Attributes that are never copied from the reference provision (even if they
  80 # do not exist in the destination object).
  81 # This is most probably because they are populated automatcally when object is
  82 # created
  83 # This also apply to imported object from reference provision
  84 hashAttrNotCopied = {   "dn": 1, "whenCreated": 1, "whenChanged": 1,
  85                         "objectGUID": 1, "uSNCreated": 1,
  86                         "replPropertyMetaData": 1, "uSNChanged": 1,
  87                         "parentGUID": 1, "objectCategory": 1,
  88                         "distinguishedName": 1, "nTMixedDomain": 1,
  89                         "showInAdvancedViewOnly": 1, "instanceType": 1,
  90                         "msDS-Behavior-Version":1, "nextRid":1, "cn": 1,
  91                         "lmPwdHistory":1, "pwdLastSet": 1,
  92                         "ntPwdHistory":1, "unicodePwd":1,"dBCSPwd":1,
  93                         "supplementalCredentials":1, "gPCUserExtensionNames":1,
  94                         "gPCMachineExtensionNames":1,"maxPwdAge":1, "secret":1,
  95                         "possibleInferiors":1, "privilege":1,
  96                         "sAMAccountType":1 }
  97
  98 # Usually for an object that already exists we do not overwrite attributes as
  99 # they might have been changed for good reasons. Anyway for a few of them it's
 100 # mandatory to replace them otherwise the provision will be broken somehow.
 101 # But for attribute that are just missing we do not have to specify them as the default
 102 # behavior is to add missing attribute
 103 hashOverwrittenAtt = {  "prefixMap": replace, "systemMayContain": replace,
 104                         "systemOnly":replace, "searchFlags":replace,
 105                         "mayContain":replace, "systemFlags":replace+add,
 106                         "description":replace, "operatingSystemVersion":replace,
 107                         "adminPropertyPages":replace, "groupType":replace,
 108                         "wellKnownObjects":replace, "privilege":never,
 109                         "defaultSecurityDescriptor": replace,
 110                         "rIDAvailablePool": never,
 111                         "rIDNextRID": add, "rIDUsedPool": never,
 112                         "defaultSecurityDescriptor": replace + add,
 113                         "isMemberOfPartialAttributeSet": delete,
 114                         "attributeDisplayNames": replace + add,
 115                         "versionNumber": add}
 116
 117 backlinked = []
 118 forwardlinked = set()
 119 dn_syntax_att = []
 120 def define_what_to_log(opts):
 121     what = 0
 122     if opts.debugchange:
 123         what = what | CHANGE
 124     if opts.debugchangesd:
 125         what = what | CHANGESD
 126     if opts.debugguess:
 127         what = what | GUESS
 128     if opts.debugprovision:
 129         what = what | PROVISION
 130     if opts.debugall:
 131         what = what | CHANGEALL
 132     return what
 133
 134
 135 parser = optparse.OptionParser("provision [options]")
 136 sambaopts = options.SambaOptions(parser)
 137 parser.add_option_group(sambaopts)
 138 parser.add_option_group(options.VersionOptions(parser))
 139 credopts = options.CredentialsOptions(parser)
 140 parser.add_option_group(credopts)
 141 parser.add_option("--setupdir", type="string", metavar="DIR",
 142                   help="directory with setup files")
 143 parser.add_option("--debugprovision", help="Debug provision", action="store_true")
 144 parser.add_option("--debugguess", action="store_true",
 145                   help="Print information on what is different but won't be changed")
 146 parser.add_option("--debugchange", action="store_true",
 147                   help="Print information on what is different but won't be changed")
 148 parser.add_option("--debugchangesd", action="store_true",
 149                   help="Print information security descriptors differences")
 150 parser.add_option("--debugall", action="store_true",
 151                   help="Print all available information (very verbose)")
 152 parser.add_option("--resetfileacl", action="store_true",
 153                   help="Force a reset on filesystem acls in sysvol / netlogon share")
 154 parser.add_option("--full", action="store_true",
 155                   help="Perform full upgrade of the samdb (schema, configuration, new objects, ...")
 156
 157 opts = parser.parse_args()[0]
 158
 159 handler = logging.StreamHandler(sys.stdout)
 160 upgrade_logger = logging.getLogger("upgradeprovision")
 161 upgrade_logger.setLevel(logging.INFO)
 162
 163 upgrade_logger.addHandler(handler)
 164
 165 provision_logger = logging.getLogger("provision")
 166 provision_logger.addHandler(handler)
 167
 168 whatToLog = define_what_to_log(opts)
 169
 170 def message(what, text):
 171     """Print a message if this message type has been selected to be printed
 172
 173     :param what: Category of the message
 174     :param text: Message to print """
 175     if (whatToLog & what) or what <= 0:
 176         upgrade_logger.info("%s", text)
 177
 178 if len(sys.argv) == 1:
 179     opts.interactive = True
 180 lp = sambaopts.get_loadparm()
 181 smbconf = lp.configfile
 182
 183 creds = credopts.get_credentials(lp)
 184 creds.set_kerberos_state(DONT_USE_KERBEROS)
 185 setup_dir = opts.setupdir
 186 if setup_dir is None:
 187     setup_dir = find_setup_dir()
 188
 189
 190
 191 def check_for_DNS(refprivate, private):
 192     """Check if the provision has already the requirement for dynamic dns
 193
 194     :param refprivate: The path to the private directory of the reference
 195                        provision
 196     :param private: The path to the private directory of the upgraded
 197                     provision"""
 198
 199     spnfile = "%s/spn_update_list" % private
 200     dnsfile = "%s/dns_update_list" % private
 201     namedfile = lp.get("dnsupdate:path")
 202
 203     if not namedfile:
 204        namedfile = "%s/named.conf.update" % private
 205
 206     if not os.path.exists(spnfile):
 207         shutil.copy("%s/spn_update_list" % refprivate, "%s" % spnfile)
 208
 209     if not os.path.exists(dnsfile):
 210         shutil.copy("%s/dns_update_list" % refprivate, "%s" % dnsfile)
 211
 212     destdir = "%s/new_dns" % private
 213     dnsdir = "%s/dns" % private
 214
 215     if not os.path.exists(namedfile):
 216         if not os.path.exists(destdir):
 217             os.mkdir(destdir)
 218         if not os.path.exists(dnsdir):
 219             os.mkdir(dnsdir)
 220         shutil.copy("%s/named.conf" % refprivate, "%s/named.conf" % destdir)
 221         shutil.copy("%s/named.txt" % refprivate, "%s/named.txt" % destdir)
 222         message(SIMPLE, "It seems that you provision didn't integrate new rules "
 223                 "for dynamic dns update of domain related entries")
 224         message(SIMPLE, "A copy of the new bind configuration files and "
 225                 "template as been put in %s, you should read them and configure dynamic "
 226                 " dns update" % destdir)
 227
 228
 229 def populate_links(samdb, schemadn):
 230     """Populate an array with all the back linked attributes
 231
 232     This attributes that are modified automaticaly when
 233     front attibutes are changed
 234
 235     :param samdb: A LDB object for sam.ldb file
 236     :param schemadn: DN of the schema for the partition"""
 237     linkedAttHash = get_linked_attributes(Dn(samdb, str(schemadn)), samdb)
 238     backlinked.extend(linkedAttHash.values())
 239     for t in linkedAttHash.keys():
 240         forwardlinked.add(t)
 241
 242
 243 def populate_dnsyntax(samdb, schemadn):
 244     """Populate an array with all the attributes that have DN synthax
 245        (oid 2.5.5.1)
 246
 247     :param samdb: A LDB object for sam.ldb file
 248     :param schemadn: DN of the schema for the partition"""
 249     res = samdb.search(expression="(attributeSyntax=2.5.5.1)", base=Dn(samdb,
 250                         str(schemadn)), scope=SCOPE_SUBTREE,
 251                         attrs=["lDAPDisplayName"])
 252     for elem in res:
 253         dn_syntax_att.append(elem["lDAPDisplayName"])
 254
 255
 256 def sanitychecks(samdb, names):
 257     """Make some checks before trying to update
 258
 259     :param samdb: An LDB object opened on sam.ldb
 260     :param names: list of key provision parameters
 261     :return: Status of check (1 for Ok, 0 for not Ok) """
 262     res = samdb.search(expression="objectClass=ntdsdsa", base=str(names.configdn),
 263                          scope=SCOPE_SUBTREE, attrs=["dn"],
 264                          controls=["search_options:1:2"])
 265     if len(res) == 0:
 266         print "No DC found, your provision is most probably hardly broken !"
 267         return False
 268     elif len(res) != 1:
 269         print "Found %d domain controllers, for the moment upgradeprovision" \
 270               "is not able to handle upgrade on domain with more than one DC, please demote" \
 271               " the other(s) DC(s) before upgrading" % len(res)
 272         return False
 273     else:
 274         return True
 275
 276
 277 def print_provision_key_parameters(names):
 278     """Do a a pretty print of provision parameters
 279
 280     :param names: list of key provision parameters """
 281     message(GUESS, "rootdn      :" + str(names.rootdn))
 282     message(GUESS, "configdn    :" + str(names.configdn))
 283     message(GUESS, "schemadn    :" + str(names.schemadn))
 284     message(GUESS, "serverdn    :" + str(names.serverdn))
 285     message(GUESS, "netbiosname :" + names.netbiosname)
 286     message(GUESS, "defaultsite :" + names.sitename)
 287     message(GUESS, "dnsdomain   :" + names.dnsdomain)
 288     message(GUESS, "hostname    :" + names.hostname)
 289     message(GUESS, "domain      :" + names.domain)
 290     message(GUESS, "realm       :" + names.realm)
 291     message(GUESS, "invocationid:" + names.invocation)
 292     message(GUESS, "policyguid  :" + names.policyid)
 293     message(GUESS, "policyguiddc:" + str(names.policyid_dc))
 294     message(GUESS, "domainsid   :" + str(names.domainsid))
 295     message(GUESS, "domainguid  :" + names.domainguid)
 296     message(GUESS, "ntdsguid    :" + names.ntdsguid)
 297     message(GUESS, "domainlevel :" + str(names.domainlevel))
 298
 299
 300 def handle_special_case(att, delta, new, old, usn, basedn, aldb):
 301     """Define more complicate update rules for some attributes
 302
 303     :param att: The attribute to be updated
 304     :param delta: A messageElement object that correspond to the difference
 305                   between the updated object and the reference one
 306     :param new: The reference object
 307     :param old: The Updated object
 308     :param usn: The highest usn modified by a previous (upgrade)provision
 309     :param basedn: The base DN of the provision
 310     :param aldb: An ldb object used to build DN
 311     :return: True to indicate that the attribute should be kept, False for
 312              discarding it"""
 313
 314     flag = delta.get(att).flags()
 315     # We do most of the special case handle if we do not have the
 316     # highest usn as otherwise the replPropertyMetaData will guide us more
 317     # correctly
 318     if usn is None:
 319         if (att == "sPNMappings" and flag == FLAG_MOD_REPLACE and
 320             ldb.Dn(aldb, "CN=Directory Service,CN=Windows NT,"
 321                         "CN=Services,CN=Configuration,%s" % basedn)
 322                         == old[0].dn):
 323             return True
 324         if (att == "userAccountControl" and flag == FLAG_MOD_REPLACE and
 325             ldb.Dn(aldb, "CN=Administrator,CN=Users,%s" % basedn)
 326                         == old[0].dn):
 327             message(SIMPLE, "We suggest that you change the userAccountControl"
 328                             " for user Administrator from value %d to %d" %
 329                             (int(str(old[0][att])), int(str(new[0][att]))))
 330             return False
 331         if (att == "minPwdAge" and flag == FLAG_MOD_REPLACE):
 332             if (long(str(old[0][att])) == 0):
 333                 delta[att] = MessageElement(new[0][att], FLAG_MOD_REPLACE, att)
 334             return True
 335
 336         if (att == "member" and flag == FLAG_MOD_REPLACE):
 337             hash = {}
 338             newval = []
 339             changeDelta=0
 340             for elem in old[0][att]:
 341                 hash[str(elem).lower()]=1
 342                 newval.append(str(elem))
 343
 344             for elem in new[0][att]:
 345                 if not hash.has_key(str(elem).lower()):
 346                     changeDelta=1
 347                     newval.append(str(elem))
 348             if changeDelta == 1:
 349                 delta[att] = MessageElement(newval, FLAG_MOD_REPLACE, att)
 350             else:
 351                 delta.remove(att)
 352             return True
 353
 354         if (att in ("gPLink", "gPCFileSysPath") and
 355             flag == FLAG_MOD_REPLACE and
 356             str(new[0].dn).lower() == str(old[0].dn).lower()):
 357             delta.remove(att)
 358             return True
 359
 360         if att == "forceLogoff":
 361             ref=0x8000000000000000
 362             oldval=int(old[0][att][0])
 363             newval=int(new[0][att][0])
 364             ref == old and ref == abs(new)
 365             return True
 366
 367         if att in ("adminDisplayName", "adminDescription"):
 368             return True
 369
 370         if (str(old[0].dn) == "CN=Samba4-Local-Domain, %s" % (names.schemadn)
 371             and att == "defaultObjectCategory" and flag == FLAG_MOD_REPLACE):
 372             return True
 373
 374         if (str(old[0].dn) == "CN=Title, %s" % (str(names.schemadn)) and
 375                 att == "rangeUpper" and flag == FLAG_MOD_REPLACE):
 376             return True
 377
 378         if (str(old[0].dn) == "%s" % (str(names.rootdn))
 379                 and att == "subRefs" and flag == FLAG_MOD_REPLACE):
 380             return True
 381
 382         if str(delta.dn).endswith("CN=DisplaySpecifiers, %s" % names.configdn):
 383             return True
 384
 385     # This is a bit of special animal as we might have added
 386     # already SPN entries to the list that has to be modified
 387     # So we go in detail to try to find out what has to be added ...
 388     if (att == "servicePrincipalName" and flag == FLAG_MOD_REPLACE):
 389         hash = {}
 390         newval = []
 391         changeDelta=0
 392         for elem in old[0][att]:
 393             hash[str(elem)]=1
 394             newval.append(str(elem))
 395
 396         for elem in new[0][att]:
 397             if not hash.has_key(str(elem)):
 398                 changeDelta=1
 399                 newval.append(str(elem))
 400         if changeDelta == 1:
 401             delta[att] = MessageElement(newval, FLAG_MOD_REPLACE, att)
 402         else:
 403             delta.remove(att)
 404         return True
 405
 406     return False
 407
 408 def dump_denied_change(dn, att, flagtxt, current, reference):
 409     """Print detailed information about why a changed is denied
 410
 411     :param dn: DN of the object which attribute is denied
 412     :param att: Attribute that was supposed to be upgraded
 413     :param flagtxt: Type of the update that should be performed
 414                     (add, change, remove, ...)
 415     :param current: Value(s) of the current attribute
 416     :param reference: Value(s) of the reference attribute"""
 417
 418     message(CHANGE, "dn= " + str(dn)+" " + att+" with flag " + flagtxt
 419                 +" is not allowed to be changed/removed, I discard this change")
 420     if att == "objectSid" :
 421         message(CHANGE, "old : %s" % ndr_unpack(security.dom_sid, current[0]))
 422         message(CHANGE, "new : %s" % ndr_unpack(security.dom_sid, reference[0]))
 423     elif att == "rIDPreviousAllocationPool" or att == "rIDAllocationPool":
 424         message(CHANGE, "old : %s" % int64range2str(current[0]))
 425         message(CHANGE, "new : %s" % int64range2str(reference[0]))
 426     else:
 427         i = 0
 428         for e in range(0, len(current)):
 429             message(CHANGE, "old %d : %s" % (i, str(current[e])))
 430             i+=1
 431         if reference is not None:
 432             i = 0
 433             for e in range(0, len(reference)):
 434                 message(CHANGE, "new %d : %s" % (i, str(reference[e])))
 435                 i+=1
 436
 437 def handle_special_add(samdb, dn, names):
 438     """Handle special operation (like remove) on some object needed during
 439     upgrade
 440
 441     This is mostly due to wrong creation of the object in previous provision.
 442     :param samdb: An Ldb object representing the SAM database
 443     :param dn: DN of the object to inspect
 444     :param names: list of key provision parameters
 445     """
 446
 447     dntoremove = None
 448     objDn = Dn(samdb, "CN=IIS_IUSRS, CN=Builtin, %s" % names.rootdn)
 449     if dn == objDn :
 450         #This entry was misplaced lets remove it if it exists
 451         dntoremove = "CN=IIS_IUSRS, CN=Users, %s" % names.rootdn
 452
 453     objDn = Dn(samdb,
 454                 "CN=Certificate Service DCOM Access, CN=Builtin, %s" % names.rootdn)
 455     if dn == objDn:
 456         #This entry was misplaced lets remove it if it exists
 457         dntoremove = "CN=Certificate Service DCOM Access,"\
 458                      "CN=Users, %s" % names.rootdn
 459
 460     objDn = Dn(samdb, "CN=Cryptographic Operators, CN=Builtin, %s" % names.rootdn)
 461     if dn == objDn:
 462         #This entry was misplaced lets remove it if it exists
 463         dntoremove = "CN=Cryptographic Operators, CN=Users, %s" % names.rootdn
 464
 465     objDn = Dn(samdb, "CN=Event Log Readers, CN=Builtin, %s" % names.rootdn)
 466     if dn == objDn:
 467         #This entry was misplaced lets remove it if it exists
 468         dntoremove = "CN=Event Log Readers, CN=Users, %s" % names.rootdn
 469
 470     objDn = Dn(samdb,"CN=System,CN=WellKnown Security Principals,"
 471                      "CN=Configuration,%s" % names.rootdn)
 472     if dn == objDn:
 473         oldDn = Dn(samdb,"CN=Well-Known-Security-Id-System,"
 474                          "CN=WellKnown Security Principals,"
 475                          "CN=Configuration,%s" % names.rootdn)
 476
 477         res = samdb.search(expression="(dn=%s)" % oldDn,
 478                             base=str(names.rootdn),
 479                             scope=SCOPE_SUBTREE, attrs=["dn"],
 480                             controls=["search_options:1:2"])
 481
 482         res2 = samdb.search(expression="(dn=%s)" % dn,
 483                             base=str(names.rootdn),
 484                             scope=SCOPE_SUBTREE, attrs=["dn"],
 485                             controls=["search_options:1:2"])
 486
 487         if len(res) > 0 and len(res2) == 0:
 488             message(CHANGE, "Existing object %s must be replaced by %s,"
 489                             "Renaming old object" % (str(oldDn), str(dn)))
 490             samdb.rename(oldDn, objDn, ["relax:0"])
 491
 492         return 0
 493
 494     if dntoremove is not None:
 495         res = samdb.search(expression="(cn=RID Set)",
 496                             base=str(names.rootdn),
 497                             scope=SCOPE_SUBTREE, attrs=["dn"],
 498                             controls=["search_options:1:2"])
 499
 500         if len(res) == 0:
 501             return 2
 502         res = samdb.search(expression="(dn=%s)" % dntoremove,
 503                             base=str(names.rootdn),
 504                             scope=SCOPE_SUBTREE, attrs=["dn"],
 505                             controls=["search_options:1:2"])
 506         if len(res) > 0:
 507             message(CHANGE, "Existing object %s must be replaced by %s,"
 508                             "removing old object" % (dntoremove, str(dn)))
 509             samdb.delete(res[0]["dn"])
 510             return 0
 511
 512     return 1
 513
 514
 515 def check_dn_nottobecreated(hash, index, listdn):
 516     """Check if one of the DN present in the list has a creation order
 517        greater than the current.
 518
 519     Hash is indexed by dn to be created, with each key
 520     is associated the creation order.
 521
 522     First dn to be created has the creation order 0, second has 1, ...
 523     Index contain the current creation order
 524
 525     :param hash: Hash holding the different DN of the object to be
 526                   created as key
 527     :param index: Current creation order
 528     :param listdn: List of DNs on which the current DN depends on
 529     :return: None if the current object do not depend on other
 530               object or if all object have been created before."""
 531     if listdn is None:
 532         return None
 533     for dn in listdn:
 534         key = str(dn).lower()
 535         if hash.has_key(key) and hash[key] > index:
 536             return str(dn)
 537     return None
 538
 539
 540
 541 def add_missing_object(ref_samdb, samdb, dn, names, basedn, hash, index):
 542     """Add a new object if the dependencies are satisfied
 543
 544     The function add the object if the object on which it depends are already
 545     created
 546
 547     :param ref_samdb: Ldb object representing the SAM db of the reference
 548                        provision
 549     :param samdb: Ldb object representing the SAM db of the upgraded
 550                    provision
 551     :param dn: DN of the object to be added
 552     :param names: List of key provision parameters
 553     :param basedn: DN of the partition to be updated
 554     :param hash: Hash holding the different DN of the object to be
 555                   created as key
 556     :param index: Current creation order
 557     :return: True if the object was created False otherwise"""
 558
 559     ret = handle_special_add(samdb, dn, names)
 560
 561     if ret == 2:
 562         return False
 563
 564     if ret == 0:
 565         return True
 566
 567
 568     reference = ref_samdb.search(expression="dn=%s" % (str(dn)), base=basedn,
 569                     scope=SCOPE_SUBTREE, controls=["search_options:1:2"])
 570     empty = Message()
 571     delta = samdb.msg_diff(empty, reference[0])
 572     delta.dn
 573     skip = False
 574     try:
 575         if str(reference[0].get("cn"))  == "RID Set":
 576             for klass in reference[0].get("objectClass"):
 577                 if str(klass).lower() == "ridset":
 578                     skip = True
 579     finally:
 580         if delta.get("objectSid"):
 581             sid = str(ndr_unpack(security.dom_sid, str(reference[0]["objectSid"])))
 582             m = re.match(r".*-(\d+)$", sid)
 583             if m and int(m.group(1))>999:
 584                 delta.remove("objectSid")
 585         for att in hashAttrNotCopied.keys():
 586             delta.remove(att)
 587         for att in backlinked:
 588             delta.remove(att)
 589         depend_on_yettobecreated = None
 590         for att in dn_syntax_att:
 591             depend_on_yet_tobecreated = check_dn_nottobecreated(hash, index,
 592                                                                 delta.get(str(att)))
 593             if depend_on_yet_tobecreated is not None:
 594                 message(CHANGE, "Object %s depends on %s in attribute %s,"
 595                                 "delaying the creation" % (dn,
 596                                           depend_on_yet_tobecreated, att))
 597                 return False
 598
 599         delta.dn = dn
 600         if not skip:
 601             message(CHANGE,"Object %s will be added" % dn)
 602             samdb.add(delta, ["relax:0"])
 603         else:
 604             message(CHANGE,"Object %s was skipped" % dn)
 605
 606         return True
 607
 608 def gen_dn_index_hash(listMissing):
 609     """Generate a hash associating the DN to its creation order
 610
 611     :param listMissing: List of DN
 612     :return: Hash with DN as keys and creation order as values"""
 613     hash = {}
 614     for i in range(0, len(listMissing)):
 615         hash[str(listMissing[i]).lower()] = i
 616     return hash
 617
 618 def add_deletedobj_containers(ref_samdb, samdb, names):
 619     """Add the object containter: CN=Deleted Objects
 620
 621     This function create the container for each partition that need one and
 622     then reference the object into the root of the partition
 623
 624     :param ref_samdb: Ldb object representing the SAM db of the reference
 625                        provision
 626     :param samdb: Ldb object representing the SAM db of the upgraded provision
 627     :param names: List of key provision parameters"""
 628
 629
 630     wkoPrefix = "B:32:18E2EA80684F11D2B9AA00C04F79F805"
 631     partitions = [str(names.rootdn), str(names.configdn)]
 632     for part in partitions:
 633         ref_delObjCnt = ref_samdb.search(expression="(cn=Deleted Objects)",
 634                                             base=part, scope=SCOPE_SUBTREE,
 635                                             attrs=["dn"],
 636                                             controls=["show_deleted:0"])
 637         delObjCnt = samdb.search(expression="(cn=Deleted Objects)",
 638                                     base=part, scope=SCOPE_SUBTREE,
 639                                     attrs=["dn"],
 640                                     controls=["show_deleted:0"])
 641         if len(ref_delObjCnt) > len(delObjCnt):
 642             reference = ref_samdb.search(expression="cn=Deleted Objects",
 643                                             base=part, scope=SCOPE_SUBTREE,
 644                                             controls=["show_deleted:0"])
 645             empty = Message()
 646             delta = samdb.msg_diff(empty, reference[0])
 647
 648             delta.dn = Dn(samdb, str(reference[0]["dn"]))
 649             for att in hashAttrNotCopied.keys():
 650                 delta.remove(att)
 651             samdb.add(delta)
 652
 653             listwko = []
 654             res = samdb.search(expression="(objectClass=*)", base=part,
 655                                scope=SCOPE_BASE,
 656                                attrs=["dn", "wellKnownObjects"])
 657
 658             targetWKO = "%s:%s" % (wkoPrefix, str(reference[0]["dn"]))
 659             found = False
 660
 661             if len(res[0]) > 0:
 662                 wko = res[0]["wellKnownObjects"]
 663
 664                 # The wellKnownObject that we want to add.
 665                 for o in wko:
 666                     if str(o) == targetWKO:
 667                         found = True
 668                     listwko.append(str(o))
 669
 670             if not found:
 671                 listwko.append(targetWKO)
 672
 673                 delta = Message()
 674                 delta.dn = Dn(samdb, str(res[0]["dn"]))
 675                 delta["wellKnownObjects"] = MessageElement(listwko,
 676                                                 FLAG_MOD_REPLACE,
 677                                                 "wellKnownObjects" )
 678                 samdb.modify(delta)
 679
 680 def add_missing_entries(ref_samdb, samdb, names, basedn, list):
 681     """Add the missing object whose DN is the list
 682
 683     The function add the object if the objects on which it depends are
 684     already created.
 685
 686     :param ref_samdb: Ldb object representing the SAM db of the reference
 687                       provision
 688     :param samdb: Ldb object representing the SAM db of the upgraded
 689                   provision
 690     :param dn: DN of the object to be added
 691     :param names: List of key provision parameters
 692     :param basedn: DN of the partition to be updated
 693     :param list: List of DN to be added in the upgraded provision"""
 694
 695     listMissing = []
 696     listDefered = list
 697
 698     while(len(listDefered) != len(listMissing) and len(listDefered) > 0):
 699         index = 0
 700         listMissing = listDefered
 701         listDefered = []
 702         hashMissing = gen_dn_index_hash(listMissing)
 703         for dn in listMissing:
 704             ret = add_missing_object(ref_samdb, samdb, dn, names, basedn,
 705                                         hashMissing, index)
 706             index = index + 1
 707             if ret == 0:
 708                 # DN can't be created because it depends on some
 709                 # other DN in the list
 710                 listDefered.append(dn)
 711
 712     if len(listDefered) != 0:
 713         raise ProvisioningError("Unable to insert missing elements:"
 714                                 "circular references")
 715
 716 def handle_links(samdb, att, basedn, dn, value, ref_value, delta):
 717     """This function handle updates on links
 718
 719     :param samdb: An LDB object pointing to the updated provision
 720     :param att: Attribute to update
 721     :param basedn: The root DN of the provision
 722     :param dn: The DN of the inspected object
 723     :param value: The value of the attribute
 724     :param ref_value: The value of this attribute in the reference provision
 725     :param delta: The MessageElement object that will be applied for
 726                    transforming the current provision"""
 727
 728     res = samdb.search(expression="dn=%s" % dn, base=basedn,
 729                         controls=["search_options:1:2", "reveal:1"],
 730                         attrs=[att])
 731
 732     blacklist = {}
 733     hash = {}
 734     newlinklist = []
 735     changed = False
 736
 737     newlinklist.extend(value)
 738
 739     for e in value:
 740         hash[e] = 1
 741     # for w2k domain level the reveal won't reveal anything ...
 742     # it means that we can readd links that were removed on purpose ...
 743     # Also this function in fact just accept add not removal
 744
 745     for e in res[0][att]:
 746         if not hash.has_key(e):
 747             # We put in the blacklist all the element that are in the "revealed"
 748             # result and not in the "standard" result
 749             # This element are links that were removed before and so that
 750             # we don't wan't to readd
 751             blacklist[e] = 1
 752
 753     for e in ref_value:
 754         if not blacklist.has_key(e) and not hash.has_key(e):
 755             newlinklist.append(str(e))
 756             changed = True
 757     if changed:
 758         delta[att] = MessageElement(newlinklist, FLAG_MOD_REPLACE, att)
 759     else:
 760         delta.remove(att)
 761
 762
 763 msg_elt_flag_strs = {
 764     ldb.FLAG_MOD_ADD: "MOD_ADD",
 765     ldb.FLAG_MOD_REPLACE: "MOD_REPLACE",
 766     ldb.FLAG_MOD_DELETE: "MOD_DELETE" }
 767
 768
 769 def update_present(ref_samdb, samdb, basedn, listPresent, usns, invocationid):
 770     """ This function updates the object that are already present in the
 771         provision
 772
 773     :param ref_samdb: An LDB object pointing to the reference provision
 774     :param samdb: An LDB object pointing to the updated provision
 775     :param basedn: A string with the value of the base DN for the provision
 776                    (ie. DC=foo, DC=bar)
 777     :param listPresent: A list of object that is present in the provision
 778     :param usns: A list of USN range modified by previous provision and
 779                  upgradeprovision
 780     :param invocationid: The value of the invocationid for the current DC"""
 781
 782     global defSDmodified
 783     # This hash is meant to speedup lookup of attribute name from an oid,
 784     # it's for the replPropertyMetaData handling
 785     hash_oid_name = {}
 786     res = samdb.search(expression="objectClass=attributeSchema", base=basedn,
 787                         controls=["search_options:1:2"], attrs=["attributeID",
 788                         "lDAPDisplayName"])
 789     if len(res) > 0:
 790         for e in res:
 791             strDisplay = str(e.get("lDAPDisplayName"))
 792             hash_oid_name[str(e.get("attributeID"))] = strDisplay
 793     else:
 794         msg = "Unable to insert missing elements: circular references"
 795         raise ProvisioningError(msg)
 796
 797     changed = 0
 798     controls = ["search_options:1:2", "sd_flags:1:2"]
 799     for dn in listPresent:
 800         reference = ref_samdb.search(expression="dn=%s" % (str(dn)), base=basedn,
 801                                         scope=SCOPE_SUBTREE,
 802                                         controls=controls)
 803         current = samdb.search(expression="dn=%s" % (str(dn)), base=basedn,
 804                                 scope=SCOPE_SUBTREE, controls=controls)
 805
 806         if (
 807              (str(current[0].dn) != str(reference[0].dn)) and
 808              (str(current[0].dn).upper() == str(reference[0].dn).upper())
 809            ):
 810             message(CHANGE, "Name are the same but case change,"\
 811                             "let's rename %s to %s" % (str(current[0].dn),
 812                                                        str(reference[0].dn)))
 813             identic_rename(samdb, reference[0].dn)
 814             current = samdb.search(expression="dn=%s" % (str(dn)), base=basedn,
 815                                     scope=SCOPE_SUBTREE,
 816                                     controls=["search_options:1:2"])
 817
 818         delta = samdb.msg_diff(current[0], reference[0])
 819
 820         for att in hashAttrNotCopied.keys():
 821             delta.remove(att)
 822
 823         for att in backlinked:
 824             delta.remove(att)
 825
 826         delta.remove("name")
 827
 828         if len(delta.items()) > 1 and usns is not None:
 829             # Fetch the replPropertyMetaData
 830             res = samdb.search(expression="dn=%s" % (str(dn)), base=basedn,
 831                                 scope=SCOPE_SUBTREE, controls=controls,
 832                                 attrs=["replPropertyMetaData"])
 833             ctr = ndr_unpack(drsblobs.replPropertyMetaDataBlob,
 834                                 str(res[0]["replPropertyMetaData"])).ctr
 835
 836             hash_attr_usn = {}
 837             for o in ctr.array:
 838                 # We put in this hash only modification
 839                 # made on the current host
 840                 att = hash_oid_name[samdb.get_oid_from_attid(o.attid)]
 841                 if str(o.originating_invocation_id) == str(invocationid):
 842                 # Note we could just use 1 here
 843                     hash_attr_usn[att] = o.originating_usn
 844                 else:
 845                     hash_attr_usn[att] = -1
 846
 847         isFirst = 0
 848         txt = ""
 849
 850         for att in delta:
 851             if usns is not None:
 852                 # We have updated by provision usn information so let's exploit
 853                 # replMetadataProperties
 854                 if att in forwardlinked:
 855                     handle_links(samdb, att, basedn, current[0]["dn"],
 856                                     current[0][att], reference[0][att], delta)
 857
 858                 if isFirst == 0 and len(delta.items())>1:
 859                     isFirst = 1
 860                     txt = "%s\n" % (str(dn))
 861                 if att == "dn":
 862                     # There is always a dn attribute after a msg_diff
 863                     continue
 864                 if att == "rIDAvailablePool":
 865                     delta.remove(att)
 866                     continue
 867                 if att == "objectSid":
 868                     delta.remove(att)
 869                     continue
 870                 if att == "creationTime":
 871                     delta.remove(att)
 872                     continue
 873                 if att == "oEMInformation":
 874                     delta.remove(att)
 875                     continue
 876                 if att == "msDs-KeyVersionNumber":
 877                 # This is the kvno of the computer/user it's a very bad
 878                 # idea to change it
 879                     delta.remove(att)
 880                     continue
 881                 if handle_special_case(att, delta, reference, current, usns, basedn, samdb):
 882                     # This attribute is "complicated" to handle and handling
 883                     # was done in handle_special_case
 884                     continue
 885                 attrUSN = hash_attr_usn.get(att)
 886                 if att == "forceLogoff" and attrUSN is None:
 887                     continue
 888                 if  attrUSN is None:
 889                     delta.remove(att)
 890                     continue
 891
 892                 if attrUSN == -1:
 893                     # This attribute was last modified by another DC forget
 894                     # about it
 895                     message(CHANGE, "%sAttribute: %s has been"
 896                             "created/modified/deleted  by another DC,"
 897                             " do nothing" % (txt, att ))
 898                     txt = ""
 899                     delta.remove(att)
 900                     continue
 901                 elif not usn_in_range(int(attrUSN), usns):
 902                     message(CHANGE, "%sAttribute: %s has been"
 903                                     "created/modified/deleted not during a"
 904                                     " provision or upgradeprovision: current"
 905                                     " usn %d , do nothing" % (txt, att, attrUSN))
 906                     txt = ""
 907                     delta.remove(att)
 908                     continue
 909                 else:
 910                     if att == "defaultSecurityDescriptor":
 911                         defSDmodified = True
 912                     if attrUSN:
 913                         message(CHANGE, "%sAttribute: %s will be modified"
 914                                         "/deleted it was last modified"
 915                                         "during a provision, current usn:"
 916                                         "%d" % (txt, att,  attrUSN))
 917                         txt = ""
 918                     else:
 919                         message(CHANGE, "%sAttribute: %s will be added because"
 920                                         " it hasn't existed before " % (txt, att))
 921                         txt = ""
 922                     continue
 923
 924             else:
 925             # Old school way of handling things for pre alpha12 upgrade
 926                 defSDmodified = True
 927                 msgElt = delta.get(att)
 928
 929                 if att == "nTSecurityDescriptor":
 930                     delta.remove(att)
 931                     continue
 932
 933                 if att == "dn":
 934                     continue
 935
 936                 if not hashOverwrittenAtt.has_key(att):
 937                     if msgElt.flags() != FLAG_MOD_ADD:
 938                         if not handle_special_case(att, delta, reference, current,
 939                                                     usns, basedn, samdb):
 940                             if opts.debugchange or opts.debugall:
 941                                 try:
 942                                     dump_denied_change(dn, att,
 943                                         msg_elt_flag_strs[msgElt.flags()],
 944                                         current[0][att], reference[0][att])
 945                                 except KeyError:
 946                                     dump_denied_change(dn, att,
 947                                         msg_elt_flag_strs[msgElt.flags()],
 948                                         current[0][att], None)
 949                             delta.remove(att)
 950                         continue
 951                 else:
 952                     if hashOverwrittenAtt.get(att)&2**msgElt.flags() :
 953                         continue
 954                     elif  hashOverwrittenAtt.get(att)==never:
 955                         delta.remove(att)
 956                         continue
 957
 958         delta.dn = dn
 959         if len(delta.items()) >1:
 960             attributes=", ".join(delta.keys())
 961             message(CHANGE, "%s is different from the reference one, changed"
 962                             " attributes: %s\n" % (dn, attributes))
 963             changed += 1
 964             samdb.modify(delta)
 965     return changed
 966
 967 def reload_full_schema(samdb, names):
 968     """Load the updated schema with all the new and existing classes
 969        and attributes.
 970
 971     :param samdb: An LDB object connected to the sam.ldb of the update
 972                   provision
 973     :param names: List of key provision parameters
 974     """
 975
 976     current = samdb.search(expression="objectClass=*", base=str(names.schemadn),
 977                                 scope=SCOPE_SUBTREE)
 978     schema_ldif = ""
 979     prefixmap_data = ""
 980
 981     for ent in current:
 982         schema_ldif += samdb.write_ldif(ent, ldb.CHANGETYPE_NONE)
 983
 984     prefixmap_data = open(setup_path("prefixMap.txt"), 'r').read()
 985     prefixmap_data = b64encode(prefixmap_data)
 986
 987     # We don't actually add this ldif, just parse it
 988     prefixmap_ldif = "dn: cn=schema\nprefixMap:: %s\n\n" % prefixmap_data
 989
 990     dsdb._dsdb_set_schema_from_ldif(samdb, prefixmap_ldif, schema_ldif)
 991
 992
 993 def update_partition(ref_samdb, samdb, basedn, names, schema, provisionUSNs, prereloadfunc):
 994     """Check differences between the reference provision and the upgraded one.
 995
 996     It looks for all objects which base DN is name.
 997
 998     This function will also add the missing object and update existing object
 999     to add or remove attributes that were missing.
1000
1001     :param ref_sambdb: An LDB object conntected to the sam.ldb of the
1002                        reference provision
1003     :param samdb: An LDB object connected to the sam.ldb of the update
1004                   provision
1005     :param basedn: String value of the DN of the partition
1006     :param names: List of key provision parameters
1007     :param schema: A Schema object
1008     :param provisionUSNs:  The USNs modified by provision/upgradeprovision
1009                            last time
1010     :param prereloadfunc: A function that must be executed just before the reload
1011                   of the schema
1012     """
1013
1014     hash_new = {}
1015     hash = {}
1016     listMissing = []
1017     listPresent = []
1018     reference = []
1019     current = []
1020
1021     # Connect to the reference provision and get all the attribute in the
1022     # partition referred by name
1023     reference = ref_samdb.search(expression="objectClass=*", base=basedn,
1024                                     scope=SCOPE_SUBTREE, attrs=["dn"],
1025                                     controls=["search_options:1:2"])
1026
1027     current = samdb.search(expression="objectClass=*", base=basedn,
1028                                 scope=SCOPE_SUBTREE, attrs=["dn"],
1029                                 controls=["search_options:1:2"])
1030     # Create a hash for speeding the search of new object
1031     for i in range(0, len(reference)):
1032         hash_new[str(reference[i]["dn"]).lower()] = reference[i]["dn"]
1033
1034     # Create a hash for speeding the search of existing object in the
1035     # current provision
1036     for i in range(0, len(current)):
1037         hash[str(current[i]["dn"]).lower()] = current[i]["dn"]
1038
1039
1040     for k in hash_new.keys():
1041         if not hash.has_key(k):
1042             if not str(hash_new[k]) == "CN=Deleted Objects, %s" % names.rootdn:
1043                 listMissing.append(hash_new[k])
1044         else:
1045             listPresent.append(hash_new[k])
1046
1047     # Sort the missing object in order to have object of the lowest level
1048     # first (which can be containers for higher level objects)
1049     listMissing.sort(dn_sort)
1050     listPresent.sort(dn_sort)
1051
1052     # The following lines is to load the up to
1053     # date schema into our current LDB
1054     # a complete schema is needed as the insertion of attributes
1055     # and class is done against it
1056     # and the schema is self validated
1057     samdb.set_schema(schema)
1058     try:
1059         message(SIMPLE, "There are %d missing objects" % (len(listMissing)))
1060         add_deletedobj_containers(ref_samdb, samdb, names)
1061
1062         add_missing_entries(ref_samdb, samdb, names, basedn, listMissing)
1063
1064         prereloadfunc()
1065         message(SIMPLE, "Reloading a merged schema, it might trigger"\
1066                         " reindexing so please be patient")
1067         reload_full_schema(samdb, names)
1068         message(SIMPLE, "Schema reloaded !")
1069
1070         changed = update_present(ref_samdb, samdb, basedn, listPresent,
1071                                     provisionUSNs, names.invocation)
1072         message(SIMPLE, "There are %d changed objects" % (changed))
1073         return 1
1074
1075     except StandardError, err:
1076         message(ERROR, "Exception during upgrade of samdb:")
1077         (typ, val, tb) = sys.exc_info()
1078         traceback.print_exception(typ, val, tb)
1079         return 0
1080
1081
1082 def check_updated_sd(ref_sam, cur_sam, names):
1083     """Check if the security descriptor in the upgraded provision are the same
1084        as the reference
1085
1086     :param ref_sam: A LDB object connected to the sam.ldb file used as
1087                     the reference provision
1088     :param cur_sam: A LDB object connected to the sam.ldb file used as
1089                     upgraded provision
1090     :param names: List of key provision parameters"""
1091     reference = ref_sam.search(expression="objectClass=*", base=str(names.rootdn),
1092                                 scope=SCOPE_SUBTREE,
1093                                 attrs=["dn", "nTSecurityDescriptor"],
1094                                 controls=["search_options:1:2"])
1095     current = cur_sam.search(expression="objectClass=*", base=str(names.rootdn),
1096                                 scope=SCOPE_SUBTREE,
1097                                 attrs=["dn", "nTSecurityDescriptor"],
1098                                 controls=["search_options:1:2"])
1099     hash = {}
1100     for i in range(0, len(reference)):
1101         refsd = ndr_unpack(security.descriptor,
1102                     str(reference[i]["nTSecurityDescriptor"]))
1103         hash[str(reference[i]["dn"]).lower()] = refsd.as_sddl(names.domainsid)
1104
1105
1106     for i in range(0, len(current)):
1107         key = str(current[i]["dn"]).lower()
1108         if hash.has_key(key):
1109             cursd = ndr_unpack(security.descriptor,
1110                         str(current[i]["nTSecurityDescriptor"]))
1111             sddl = cursd.as_sddl(names.domainsid)
1112             if sddl != hash[key]:
1113                 txt = get_diff_sddls(hash[key], sddl)
1114                 if txt != "":
1115                     message(CHANGESD, "On object %s ACL is different"
1116                                       " \n%s" % (current[i]["dn"], txt))
1117
1118
1119
1120 def fix_partition_sd(samdb, names):
1121     """This function fix the SD for partition containers (basedn, configdn, ...)
1122     This is needed because some provision use to have broken SD on containers
1123
1124     :param samdb: An LDB object pointing to the sam of the current provision
1125     :param names: A list of key provision parameters
1126     """
1127     # First update the SD for the rootdn
1128     res = samdb.search(expression="objectClass=*", base=str(names.rootdn),
1129                          scope=SCOPE_BASE, attrs=["dn", "whenCreated"],
1130                          controls=["search_options:1:2"])
1131     delta = Message()
1132     delta.dn = Dn(samdb, str(res[0]["dn"]))
1133     descr = get_domain_descriptor(names.domainsid)
1134     delta["nTSecurityDescriptor"] = MessageElement(descr, FLAG_MOD_REPLACE,
1135                                                     "nTSecurityDescriptor")
1136     samdb.modify(delta, ["recalculate_sd:0"])
1137     # Then the config dn
1138     res = samdb.search(expression="objectClass=*", base=str(names.configdn),
1139                         scope=SCOPE_BASE, attrs=["dn", "whenCreated"],
1140                         controls=["search_options:1:2"])
1141     delta = Message()
1142     delta.dn = Dn(samdb, str(res[0]["dn"]))
1143     descr = get_config_descriptor(names.domainsid)
1144     delta["nTSecurityDescriptor"] = MessageElement(descr, FLAG_MOD_REPLACE,
1145                                                     "nTSecurityDescriptor" )
1146     samdb.modify(delta, ["recalculate_sd:0"])
1147     # Then the schema dn
1148     res = samdb.search(expression="objectClass=*", base=str(names.schemadn),
1149                         scope=SCOPE_BASE, attrs=["dn", "whenCreated"],
1150                         controls=["search_options:1:2"])
1151
1152     delta = Message()
1153     delta.dn = Dn(samdb, str(res[0]["dn"]))
1154     descr = get_schema_descriptor(names.domainsid)
1155     delta["nTSecurityDescriptor"] = MessageElement(descr, FLAG_MOD_REPLACE,
1156                                                     "nTSecurityDescriptor" )
1157     samdb.modify(delta, ["recalculate_sd:0"])
1158
1159 def rebuild_sd(samdb, names):
1160     """Rebuild security descriptor of the current provision from scratch
1161
1162     During the different pre release of samba4 security descriptors (SD)
1163     were notarly broken (up to alpha11 included)
1164     This function allow to get them back in order, this function make the
1165     assumption that nobody has modified manualy an SD
1166     and so SD can be safely recalculated from scratch to get them right.
1167
1168     :param names: List of key provision parameters"""
1169
1170
1171     hash = {}
1172     res = samdb.search(expression="objectClass=*", base=str(names.rootdn),
1173                         scope=SCOPE_SUBTREE, attrs=["dn", "whenCreated"],
1174                         controls=["search_options:1:2"])
1175     for obj in res:
1176         if not (str(obj["dn"]) == str(names.rootdn) or
1177             str(obj["dn"]) == str(names.configdn) or
1178             str(obj["dn"]) == str(names.schemadn)):
1179             hash[str(obj["dn"])] = obj["whenCreated"]
1180
1181     listkeys = hash.keys()
1182     listkeys.sort(dn_sort)
1183
1184     for key in listkeys:
1185         try:
1186             delta = Message()
1187             delta.dn = Dn(samdb, key)
1188             delta["whenCreated"] = MessageElement(hash[key], FLAG_MOD_REPLACE,
1189                                                     "whenCreated" )
1190             samdb.modify(delta, ["recalculate_sd:0"])
1191         except:
1192             # XXX: We should always catch an explicit exception.
1193             # What could go wrong here?
1194             samdb.transaction_cancel()
1195             res = samdb.search(expression="objectClass=*", base=str(names.rootdn),
1196                                 scope=SCOPE_SUBTREE,
1197                                 attrs=["dn", "nTSecurityDescriptor"],
1198                                 controls=["search_options:1:2"])
1199             badsd = ndr_unpack(security.descriptor,
1200                         str(res[0]["nTSecurityDescriptor"]))
1201             print "bad stuff %s" % badsd.as_sddl(names.domainsid)
1202             return
1203
1204 def removeProvisionUSN(samdb):
1205         attrs = [samba.provision.LAST_PROVISION_USN_ATTRIBUTE, "dn"]
1206         entry = samdb.search(expression="dn=@PROVISION", base = "",
1207                                 scope=SCOPE_SUBTREE,
1208                                 controls=["search_options:1:2"],
1209                                 attrs=attrs)
1210         empty = Message()
1211         empty.dn = entry[0].dn
1212         delta = samdb.msg_diff(entry[0], empty)
1213         delta.remove("dn")
1214         delta.dn = entry[0].dn
1215         samdb.modify(delta)
1216
1217 def remove_stored_generated_attrs(paths, creds, session, lp):
1218     """Remove previously stored constructed attributes
1219
1220     :param paths: List of paths for different provision objects
1221                         from the upgraded provision
1222     :param creds: A credential object
1223     :param session: A session object
1224     :param lp: A line parser object
1225     :return: An associative array whose key are the different constructed
1226              attributes and the value the dn where this attributes were found.
1227      """
1228
1229
1230 def simple_update_basesamdb(newpaths, paths, names):
1231     """Update the provision container db: sam.ldb
1232     This function is aimed at very old provision (before alpha9)
1233
1234     :param newpaths: List of paths for different provision objects
1235                         from the reference provision
1236     :param paths: List of paths for different provision objects
1237                         from the upgraded provision
1238     :param names: List of key provision parameters"""
1239
1240     message(SIMPLE, "Copy samdb")
1241     shutil.copy(newpaths.samdb, paths.samdb)
1242
1243     message(SIMPLE, "Update partitions filename if needed")
1244     schemaldb = os.path.join(paths.private_dir, "schema.ldb")
1245     configldb = os.path.join(paths.private_dir, "configuration.ldb")
1246     usersldb = os.path.join(paths.private_dir, "users.ldb")
1247     samldbdir = os.path.join(paths.private_dir, "sam.ldb.d")
1248
1249     if not os.path.isdir(samldbdir):
1250         os.mkdir(samldbdir)
1251         os.chmod(samldbdir, 0700)
1252     if os.path.isfile(schemaldb):
1253         shutil.copy(schemaldb, os.path.join(samldbdir,
1254                                             "%s.ldb"%str(names.schemadn).upper()))
1255         os.remove(schemaldb)
1256     if os.path.isfile(usersldb):
1257         shutil.copy(usersldb, os.path.join(samldbdir,
1258                                             "%s.ldb"%str(names.rootdn).upper()))
1259         os.remove(usersldb)
1260     if os.path.isfile(configldb):
1261         shutil.copy(configldb, os.path.join(samldbdir,
1262                                             "%s.ldb"%str(names.configdn).upper()))
1263         os.remove(configldb)
1264
1265
1266 def update_privilege(ref_private_path, cur_private_path):
1267     """Update the privilege database
1268
1269     :param ref_private_path: Path to the private directory of the reference
1270                              provision.
1271     :param cur_private_path: Path to the private directory of the current
1272                              (and to be updated) provision."""
1273     message(SIMPLE, "Copy privilege")
1274     shutil.copy(os.path.join(ref_private_path, "privilege.ldb"),
1275                 os.path.join(cur_private_path, "privilege.ldb"))
1276
1277
1278 def update_samdb(ref_samdb, samdb, names, highestUSN, schema, prereloadfunc):
1279     """Upgrade the SAM DB contents for all the provision partitions
1280
1281     :param ref_sambdb: An LDB object conntected to the sam.ldb of the reference
1282                        provision
1283     :param samdb: An LDB object connected to the sam.ldb of the update
1284                   provision
1285     :param names: List of key provision parameters
1286     :param highestUSN:  The highest USN modified by provision/upgradeprovision
1287                         last time
1288     :param schema: A Schema object that represent the schema of the provision
1289     :param prereloadfunc: A function that must be executed just before the reload
1290                   of the schema
1291     """
1292
1293     message(SIMPLE, "Starting update of samdb")
1294     ret = update_partition(ref_samdb, samdb, str(names.rootdn), names,
1295                             schema, highestUSN, prereloadfunc)
1296     if ret:
1297         message(SIMPLE, "Update of samdb finished")
1298         return 1
1299     else:
1300         message(SIMPLE, "Update failed")
1301         return 0
1302
1303
1304 def copyxattrs(dir, refdir):
1305     """ Copy owner, groups, extended ACL and NT acls from
1306     a reference dir to a destination dir
1307
1308     Both dir are supposed to hold the same files
1309     :param dir: Destination dir
1310     :param refdir: Reference directory"""
1311
1312     noxattr = 0
1313     for root, dirs, files in os.walk(dir, topdown=True):
1314         for name in files:
1315             subdir=root[len(dir):]
1316             ref = os.path.join("%s%s" % (refdir, subdir), name)
1317             statsinfo = os.stat(ref)
1318             tgt = os.path.join(root, name)
1319             try:
1320
1321                 os.chown(tgt, statsinfo.st_uid, statsinfo.st_gid)
1322                 # Get the xattr attributes if any
1323                 try:
1324                     attribute = samba.xattr_native.wrap_getxattr(ref,
1325                                                  xattr.XATTR_NTACL_NAME)
1326                     samba.xattr_native.wrap_setxattr(tgt,
1327                                                  xattr.XATTR_NTACL_NAME,
1328                                                  attribute)
1329                 except:
1330                     noxattr = 1
1331                 attribute = samba.xattr_native.wrap_getxattr(ref,
1332                                                  "system.posix_acl_access")
1333                 samba.xattr_native.wrap_setxattr(tgt,
1334                                                  "system.posix_acl_access",
1335                                                   attribute)
1336             except:
1337                 continue
1338         for name in dirs:
1339             subdir=root[len(dir):]
1340             ref = os.path.join("%s%s" % (refdir, subdir), name)
1341             statsinfo = os.stat(ref)
1342             tgt = os.path.join(root, name)
1343             try:
1344                 os.chown(os.path.join(root, name), statsinfo.st_uid,
1345                           statsinfo.st_gid)
1346                 try:
1347                     attribute = samba.xattr_native.wrap_getxattr(ref,
1348                                                  xattr.XATTR_NTACL_NAME)
1349                     samba.xattr_native.wrap_setxattr(tgt,
1350                                                  xattr.XATTR_NTACL_NAME,
1351                                                  attribute)
1352                 except:
1353                     noxattr = 1
1354                 attribute = samba.xattr_native.wrap_getxattr(ref,
1355                                                  "system.posix_acl_access")
1356                 samba.xattr_native.wrap_setxattr(tgt,
1357                                                  "system.posix_acl_access",
1358                                                   attribute)
1359
1360             except:
1361                 continue
1362
1363
1364 def backup_provision(paths, dir):
1365     """This function backup the provision files so that a rollback
1366     is possible
1367
1368     :param paths: Paths to different objects
1369     :param dir: Directory where to store the backup
1370     """
1371
1372     shutil.copytree(paths.sysvol, os.path.join(dir, "sysvol"))
1373     copyxattrs(os.path.join(dir, "sysvol"), paths.sysvol)
1374     shutil.copy2(paths.samdb, dir)
1375     shutil.copy2(paths.secrets, dir)
1376     shutil.copy2(paths.idmapdb, dir)
1377     shutil.copy2(paths.privilege, dir)
1378     if os.path.isfile(os.path.join(paths.private_dir,"eadb.tdb")):
1379         shutil.copy2(os.path.join(paths.private_dir,"eadb.tdb"), dir)
1380     shutil.copy2(paths.smbconf, dir)
1381     shutil.copy2(os.path.join(paths.private_dir,"secrets.keytab"), dir)
1382
1383     samldbdir = os.path.join(paths.private_dir, "sam.ldb.d")
1384     if not os.path.isdir(samldbdir):
1385         samldbdir = paths.private_dir
1386         schemaldb = os.path.join(paths.private_dir, "schema.ldb")
1387         configldb = os.path.join(paths.private_dir, "configuration.ldb")
1388         usersldb = os.path.join(paths.private_dir, "users.ldb")
1389         shutil.copy2(schemaldb, dir)
1390         shutil.copy2(usersldb, dir)
1391         shutil.copy2(configldb, dir)
1392     else:
1393         shutil.copytree(samldbdir, os.path.join(dir, "sam.ldb.d"))
1394
1395
1396
1397
1398 def sync_calculated_attributes(samdb, names):
1399    """Synchronize attributes used for constructed ones, with the
1400       old constructed that were stored in the database.
1401
1402       This apply for instance to msds-keyversionnumber that was
1403       stored and that is now constructed from replpropertymetadata.
1404
1405       :param samdb: An LDB object attached to the currently upgraded samdb
1406       :param names: Various key parameter about current provision.
1407    """
1408    listAttrs = ["msDs-KeyVersionNumber"]
1409    hash = search_constructed_attrs_stored(samdb, names.rootdn, listAttrs)
1410    if hash.has_key("msDs-KeyVersionNumber"):
1411        increment_calculated_keyversion_number(samdb, names.rootdn,
1412                                             hash["msDs-KeyVersionNumber"])
1413
1414 def setup_path(file):
1415     return os.path.join(setup_dir, file)
1416
1417 # Synopsis for updateprovision
1418 # 1) get path related to provision to be update (called current)
1419 # 2) open current provision ldbs
1420 # 3) fetch the key provision parameter (domain sid, domain guid, invocationid
1421 #    of the DC ....)
1422 # 4) research of lastProvisionUSN in order to get ranges of USN modified
1423 #    by either upgradeprovision or provision
1424 # 5) creation of a new provision the latest version of provision script
1425 #    (called reference)
1426 # 6) get reference provision paths
1427 # 7) open reference provision ldbs
1428 # 8) setup helpers data that will help the update process
1429 # 9) update the privilege ldb by copying the one of referecence provision to
1430 #    the current provision
1431 # 10)get the oemInfo field, this field contains information about the different
1432 #    provision that have been done
1433 # 11)Depending  on whether oemInfo has the string "alpha9" or alphaxx (x as an
1434 #    integer) or none of this the following things are done
1435 #    A) When alpha9 or alphaxx is present
1436 #       The base sam.ldb file is updated by looking at the difference between
1437 #       referrence one and the current one. Everything is copied with the
1438 #       exception of lastProvisionUSN attributes.
1439 #    B) Other case (it reflect that that provision was done before alpha9)
1440 #       The base sam.ldb of the reference provision is copied over
1441 #       the current one, if necessary ldb related to partitions are moved
1442 #       and renamed
1443 # The highest used USN is fetched so that changed by upgradeprovision
1444 # usn can be tracked
1445 # 12)A Schema object is created, it will be used to provide a complete
1446 #    schema to current provision during update (as the schema of the
1447 #    current provision might not be complete and so won't allow some
1448 #    object to be created)
1449 # 13)Proceed to full update of sam DB (see the separate paragraph about i)
1450 # 14)The secrets db is updated by pull all the difference from the reference
1451 #    provision into the current provision
1452 # 15)As the previous step has most probably modified the password stored in
1453 #    in secret for the current DC, a new password is generated,
1454 #    the kvno is bumped and the entry in samdb is also updated
1455 # 16)For current provision older than alpha9, we must fix the SD a little bit
1456 #    administrator to update them because SD used to be generated with the
1457 #    system account before alpha9.
1458 # 17)The highest usn modified so far is searched in the database it will be
1459 #    the upper limit for usn modified during provision.
1460 #    This is done before potential SD recalculation because we do not want
1461 #    SD modified during recalculation to be marked as modified during provision
1462 #    (and so possibly remplaced at next upgradeprovision)
1463 # 18)Rebuilt SD if the flag indicate to do so
1464 # 19)Check difference between SD of reference provision and those of the
1465 #    current provision. The check is done by getting the sddl representation
1466 #    of the SD. Each sddl in chuncked into parts (user,group,dacl,sacl)
1467 #    Each part is verified separetly, for dacl and sacl ACL is splited into
1468 #    ACEs and each ACE is verified separately (so that a permutation in ACE
1469 #    didn't raise as an error).
1470 # 20)The oemInfo field is updated to add information about the fact that the
1471 #    provision has been updated by the upgradeprovision version xxx
1472 #    (the version is the one obtained when starting samba with the --version
1473 #    parameter)
1474 # 21)Check if the current provision has all the settings needed for dynamic
1475 #    DNS update to work (that is to say the provision is newer than
1476 #    january 2010). If not dns configuration file from reference provision
1477 #    are copied in a sub folder and the administrator is invited to
1478 #    do what is needed.
1479 # 22)If the lastProvisionUSN attribute was present it is updated to add
1480 #    the range of usns modified by the current upgradeprovision
1481
1482
1483 # About updating the sam DB
1484 # The update takes place in update_partition function
1485 # This function read both current and reference provision and list all
1486 # the available DN of objects
1487 # If the string representation of a DN in reference provision is
1488 # equal to the string representation of a DN in current provision
1489 # (without taking care of case) then the object is flaged as being
1490 # present. If the object is not present in current provision the object
1491 # is being flaged as missing in current provision. Object present in current
1492 # provision but not in reference provision are ignored.
1493 # Once the list of objects present and missing is done, the deleted object
1494 # containers are created in the differents partitions (if missing)
1495 #
1496 # Then the function add_missing_entries is called
1497 # This function will go through the list of missing entries by calling
1498 # add_missing_object for the given object. If this function returns 0
1499 # it means that the object needs some other object in order to be created
1500 # The object is reappended at the end of the list to be created later
1501 # (and preferably after all the needed object have been created)
1502 # The function keeps on looping on the list of object to be created until
1503 # it's empty or that the number of defered creation is equal to the number
1504 # of object that still needs to be created.
1505
1506 # The function add_missing_object will first check if the object can be created.
1507 # That is to say that it didn't depends other not yet created objects
1508 # If requisit can't be fullfilled it exists with 0
1509 # Then it will try to create the missing entry by creating doing
1510 # an ldb_message_diff between the object in the reference provision and
1511 # an empty object.
1512 # This resulting object is filtered to remove all the back link attribute
1513 # (ie. memberOf) as they will be created by the other linked object (ie.
1514 # the one with the member attribute)
1515 # All attributes specified in the hashAttrNotCopied associative array are
1516 # also removed it's most of the time generated attributes
1517
1518 # After missing entries have been added the update_partition function will
1519 # take care of object that exist but that need some update.
1520 # In order to do so the function update_present is called with the list
1521 # of object that are present in both provision and that might need an update.
1522
1523 # This function handle first case mismatch so that the DN in the current
1524 # provision have the same case as in reference provision
1525
1526 # It will then construct an associative array consiting of attributes as
1527 # key and invocationid as value( if the originating invocation id is
1528 # different from the invocation id of the current DC the value is -1 instead).
1529
1530 # If the range of provision modified attributes is present, the function will
1531 # use the replMetadataProperty update method which is the following:
1532 #  Removing attributes that should not be updated: rIDAvailablePool, objectSid,
1533 #   creationTime, msDs-KeyVersionNumber, oEMInformation
1534 #  Check for each attribute if its usn is within one of the modified by
1535 #   provision range and if its originating id is the invocation id of the
1536 #   current DC, then validate the update from reference to current.
1537 #   If not or if there is no replMetatdataProperty for this attribute then we
1538 #   do not update it.
1539 # Otherwise (case the range of provision modified attribute is not present) it
1540 # use the following process:
1541 #  All attributes that need to be added are accepted at the exeption of those
1542 #   listed in hashOverwrittenAtt, in this case the attribute needs to have the
1543 #   correct flags specified.
1544 #  For attributes that need to be modified or removed, a check is performed
1545 #  in OverwrittenAtt, if the attribute is present and the modification flag
1546 #  (remove, delete) is one of those listed for this attribute then modification
1547 #  is accepted. For complicated handling of attribute update, the control is passed
1548 #  to handle_special_case
1549
1550
1551
1552 if __name__ == '__main__':
1553     global defSDmodified
1554     defSDmodified = False
1555     # From here start the big steps of the program
1556     # 1) First get files paths
1557     paths = get_paths(param, smbconf=smbconf)
1558     paths.setup = setup_dir
1559     # Get ldbs with the system session, it is needed for searching
1560     # provision parameters
1561     session = system_session()
1562
1563     # This variable will hold the last provision USN once if it exists.
1564     minUSN = 0
1565     # 2)
1566     ldbs = get_ldbs(paths, creds, session, lp)
1567     backupdir = tempfile.mkdtemp(dir=paths.private_dir,
1568                                     prefix="backupprovision")
1569     backup_provision(paths, backupdir)
1570     try:
1571         ldbs.startTransactions()
1572
1573         # 3) Guess all the needed names (variables in fact) from the current
1574         # provision.
1575         names = find_provision_key_parameters(ldbs.sam, ldbs.secrets, ldbs.idmap,
1576                                                 paths, smbconf, lp)
1577         # 4)
1578         lastProvisionUSNs = get_last_provision_usn(ldbs.sam)
1579         if lastProvisionUSNs is not None:
1580             message(CHANGE,
1581                 "Find a last provision USN, %d range(s)" % len(lastProvisionUSNs))
1582
1583         # Objects will be created with the admin session
1584         # (not anymore system session)
1585         adm_session = admin_session(lp, str(names.domainsid))
1586         # So we reget handle on objects
1587         # ldbs = get_ldbs(paths, creds, adm_session, lp)
1588
1589         if not sanitychecks(ldbs.sam, names):
1590             message(SIMPLE, "Sanity checks for the upgrade fails, checks messages"
1591                             " and correct them before rerunning upgradeprovision")
1592             sys.exit(1)
1593
1594         # Let's see provision parameters
1595         print_provision_key_parameters(names)
1596
1597         # 5) With all this information let's create a fresh new provision used as
1598         # reference
1599         message(SIMPLE, "Creating a reference provision")
1600         provisiondir = tempfile.mkdtemp(dir=paths.private_dir,
1601                                         prefix="referenceprovision")
1602         newprovision(names, setup_dir, creds, session, smbconf, provisiondir,
1603                         provision_logger)
1604
1605         # TODO
1606         # 6) and 7)
1607         # We need to get a list of object which SD is directly computed from
1608         # defaultSecurityDescriptor.
1609         # This will allow us to know which object we can rebuild the SD in case
1610         # of change of the parent's SD or of the defaultSD.
1611         # Get file paths of this new provision
1612         newpaths = get_paths(param, targetdir=provisiondir)
1613         new_ldbs = get_ldbs(newpaths, creds, session, lp)
1614         new_ldbs.startTransactions()
1615
1616         # 8) Populate some associative array to ease the update process
1617         # List of attribute which are link and backlink
1618         populate_links(new_ldbs.sam, names.schemadn)
1619         # List of attribute with ASN DN synthax)
1620         populate_dnsyntax(new_ldbs.sam, names.schemadn)
1621         # 9)
1622         update_privilege(newpaths.private_dir, paths.private_dir)
1623         # 10)
1624         oem = getOEMInfo(ldbs.sam, str(names.rootdn))
1625         # Do some modification on sam.ldb
1626         ldbs.groupedCommit()
1627         new_ldbs.groupedCommit()
1628         deltaattr = None
1629 # 11)
1630         if re.match(".*alpha((9)|(\d\d+)).*", str(oem)):
1631             # 11) A
1632             # Starting from alpha9 we can consider that the structure is quite ok
1633             # and that we should do only dela
1634             deltaattr = delta_update_basesamdb(newpaths.samdb,
1635                                                 paths.samdb,
1636                                                 creds,
1637                                                 session,
1638                                                 lp,
1639                                                 message)
1640         else:
1641             # 11) B
1642             simple_update_basesamdb(newpaths, paths, names)
1643             ldbs = get_ldbs(paths, creds, session, lp)
1644             removeProvisionUSN(ldbs.sam)
1645
1646         ldbs.startTransactions()
1647         minUSN = int(str(get_max_usn(ldbs.sam, str(names.rootdn)))) + 1
1648         new_ldbs.startTransactions()
1649
1650         # 12)
1651         schema = Schema(setup_path, names.domainsid, schemadn=str(names.schemadn),
1652                          serverdn=str(names.serverdn))
1653         # We create a closure that will be invoked just before schema reload
1654         def schemareloadclosure():
1655             basesam = Ldb(paths.samdb, session_info=session, credentials=creds, lp=lp,
1656                             options=["modules:"])
1657             doit = False
1658             if deltaattr is not None and len(deltaattr) > 1:
1659                 doit = True
1660             if doit:
1661                 deltaattr.remove("dn")
1662                 for att in deltaattr:
1663                     if att.lower() == "dn":
1664                         continue
1665                     if deltaattr.get(att) is not None \
1666                         and deltaattr.get(att).flags() != FLAG_MOD_ADD:
1667                         doit = False
1668                     elif deltaattr.get(att) is None:
1669                         doit = False
1670             if doit:
1671                 message(CHANGE, "Applying delta to @ATTRIBUTES")
1672                 deltaattr.dn = ldb.Dn(basesam, "@ATTRIBUTES")
1673                 basesam.modify(deltaattr)
1674             else:
1675                 message(CHANGE, "Not applying delta to @ATTRIBUTES because "\
1676                                 "there is not only add")
1677         # 13)
1678         if opts.full:
1679             if not update_samdb(new_ldbs.sam, ldbs.sam, names, lastProvisionUSNs,
1680                                 schema, schemareloadclosure):
1681                 message(SIMPLE, "Rollbacking every changes. Check the reason"
1682                                 " of the problem")
1683                 message(SIMPLE, "In any case your system as it was before"
1684                                 " the upgrade")
1685                 ldbs.groupedRollback()
1686                 new_ldbs.groupedRollback()
1687                 shutil.rmtree(provisiondir)
1688                 sys.exit(1)
1689         else:
1690             # Try to reapply the change also when we do not change the sam
1691             # as the delta_upgrade
1692             schemareloadclosure()
1693             sync_calculated_attributes(ldbs.sam, names)
1694         # 14)
1695         update_secrets(new_ldbs.secrets, ldbs.secrets, message)
1696         # 15)
1697         message(SIMPLE, "Update machine account")
1698         update_machine_account_password(ldbs.sam, ldbs.secrets, names)
1699
1700         # 16) SD should be created with admin but as some previous acl were so wrong
1701         # that admin can't modify them we have first to recreate them with the good
1702         # form but with system account and then give the ownership to admin ...
1703         if not re.match(r'.*alpha(9|\d\d+)', str(oem)):
1704             message(SIMPLE, "Fixing old povision SD")
1705             fix_partition_sd(ldbs.sam, names)
1706             rebuild_sd(ldbs.sam, names)
1707
1708         # We calculate the max USN before recalculating the SD because we might
1709         # touch object that have been modified after a provision and we do not
1710         # want that the next upgradeprovision thinks that it has a green light
1711         # to modify them
1712
1713         # 17)
1714         maxUSN = get_max_usn(ldbs.sam, str(names.rootdn))
1715
1716         # 18) We rebuild SD only if defaultSecurityDescriptor is modified
1717         # But in fact we should do it also if one object has its SD modified as
1718         # child might need rebuild
1719         if defSDmodified:
1720             message(SIMPLE, "Updating SD")
1721             ldbs.sam.set_session_info(adm_session)
1722             # Alpha10 was a bit broken still
1723             if re.match(r'.*alpha(\d|10)', str(oem)):
1724                 fix_partition_sd(ldbs.sam, names)
1725             rebuild_sd(ldbs.sam, names)
1726
1727         # 19)
1728         # Now we are quite confident in the recalculate process of the SD, we make
1729         # it optional.
1730         # Also the check must be done in a clever way as for the moment we just
1731         # compare SDDL
1732         if opts.debugchangesd:
1733             check_updated_sd(new_ldbs.sam, ldbs.sam, names)
1734
1735         # 20)
1736         updateOEMInfo(ldbs.sam, str(names.rootdn))
1737         # 21)
1738         check_for_DNS(newpaths.private_dir, paths.private_dir)
1739         # 22)
1740         if lastProvisionUSNs is not None:
1741             update_provision_usn(ldbs.sam, minUSN, maxUSN)
1742         if opts.full and (names.policyid is None or names.policyid_dc is None):
1743             update_policyids(names, ldbs.sam)
1744         if opts.full or opts.resetfileacl:
1745             try:
1746                 update_gpo(paths, ldbs.sam, names, lp, message, 1)
1747             except ProvisioningError, e:
1748                 message(ERROR, "The policy for domain controller is missing,"
1749                                " you should restart upgradeprovision with --full")
1750             except IOError, e:
1751                 message(ERROR, "Setting ACL not supported on your filesystem")
1752         else:
1753             try:
1754                 update_gpo(paths, ldbs.sam, names, lp, message, 0)
1755             except ProvisioningError, e:
1756                 message(ERROR, "The policy for domain controller is missing,"
1757                                " you should restart upgradeprovision with --full")
1758         ldbs.groupedCommit()
1759         new_ldbs.groupedCommit()
1760         message(SIMPLE, "Upgrade finished !")
1761         # remove reference provision now that everything is done !
1762         # So we have reindexed first if need when the merged schema was reloaded
1763         # (as new attributes could have quick in)
1764         # But the second part of the update (when we update existing objects
1765         # can also have an influence on indexing as some attribute might have their
1766         # searchflag modificated
1767         message(SIMPLE, "Reopenning samdb to trigger reindexing if needed after"\
1768                         " modification")
1769         samdb = Ldb(paths.samdb, session_info=session, credentials=creds, lp=lp)
1770         message(SIMPLE, "Reindexing finished")
1771
1772         shutil.rmtree(provisiondir)
1773     except StandardError, err:
1774         message(ERROR,"A problem has occured when trying to upgrade your provision,"
1775                       " a full backup is located at %s" % backupdir)
1776         if opts.debugall or opts.debugchange:
1777             (typ, val, tb) = sys.exc_info()
1778             traceback.print_exception(typ, val, tb)
1779         sys.exit(1)