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