python/samba/kcc/kcc_utils.py

   1 # KCC topology utilities
   2 #
   3 # Copyright (C) Dave Craft 2011
   4 # Copyright (C) Jelmer Vernooij 2011
   5 # Copyright (C) Andrew Bartlett 2015
   6 #
   7 # Andrew Bartlett's alleged work performed by his underlings Douglas
   8 # Bagnall and Garming Sam.
   9 #
  10 # This program is free software; you can redistribute it and/or modify
  11 # it under the terms of the GNU General Public License as published by
  12 # the Free Software Foundation; either version 3 of the License, or
  13 # (at your option) any later version.
  14 #
  15 # This program is distributed in the hope that it will be useful,
  16 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 # GNU General Public License for more details.
  19 #
  20 # You should have received a copy of the GNU General Public License
  21 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22
  23 import ldb
  24 import uuid
  25
  26 from samba import dsdb
  27 from samba.dcerpc import (
  28     drsblobs,
  29     drsuapi,
  30     misc,
  31 )
  32 from samba.common import dsdb_Dn
  33 from samba.ndr import ndr_unpack, ndr_pack
  34 from collections import Counter
  35
  36
  37 class KCCError(Exception):
  38     pass
  39
  40
  41 class NCType(object):
  42     (unknown, schema, domain, config, application) = range(0, 5)
  43
  44
  45 # map the NCType enum to strings for debugging
  46 nctype_lut = dict((v, k) for k, v in NCType.__dict__.items() if k[:2] != '__')
  47
  48
  49 class NamingContext(object):
  50     """Base class for a naming context.
  51
  52     Holds the DN, GUID, SID (if available) and type of the DN.
  53     Subclasses may inherit from this and specialize
  54     """
  55
  56     def __init__(self, nc_dnstr):
  57         """Instantiate a NamingContext
  58
  59         :param nc_dnstr: NC dn string
  60         """
  61         self.nc_dnstr = nc_dnstr
  62         self.nc_guid = None
  63         self.nc_sid = None
  64         self.nc_type = NCType.unknown
  65
  66     def __str__(self):
  67         '''Debug dump string output of class'''
  68         text = "%s:" % (self.__class__.__name__,)
  69         text = text + "\n\tnc_dnstr=%s" % self.nc_dnstr
  70         text = text + "\n\tnc_guid=%s" % str(self.nc_guid)
  71
  72         if self.nc_sid is None:
  73             text = text + "\n\tnc_sid=<absent>"
  74         else:
  75             text = text + "\n\tnc_sid=<present>"
  76
  77         text = text + "\n\tnc_type=%s (%s)" % (nctype_lut[self.nc_type],
  78                                                self.nc_type)
  79         return text
  80
  81     def load_nc(self, samdb):
  82         attrs = ["objectGUID",
  83                  "objectSid"]
  84         try:
  85             res = samdb.search(base=self.nc_dnstr,
  86                                scope=ldb.SCOPE_BASE, attrs=attrs)
  87
  88         except ldb.LdbError as e:
  89             (enum, estr) = e.args
  90             raise KCCError("Unable to find naming context (%s) - (%s)" %
  91                            (self.nc_dnstr, estr))
  92         msg = res[0]
  93         if "objectGUID" in msg:
  94             self.nc_guid = misc.GUID(samdb.schema_format_value("objectGUID",
  95                                      msg["objectGUID"][0]))
  96         if "objectSid" in msg:
  97             self.nc_sid = msg["objectSid"][0]
  98
  99         assert self.nc_guid is not None
 100
 101     def is_config(self):
 102         '''Return True if NC is config'''
 103         assert self.nc_type != NCType.unknown
 104         return self.nc_type == NCType.config
 105
 106     def identify_by_basedn(self, samdb):
 107         """Given an NC object, identify what type is is thru
 108            the samdb basedn strings and NC sid value
 109         """
 110         # Invoke loader to initialize guid and more
 111         # importantly sid value (sid is used to identify
 112         # domain NCs)
 113         if self.nc_guid is None:
 114             self.load_nc(samdb)
 115
 116         # We check against schema and config because they
 117         # will be the same for all nTDSDSAs in the forest.
 118         # That leaves the domain NCs which can be identified
 119         # by sid and application NCs as the last identified
 120         if self.nc_dnstr == str(samdb.get_schema_basedn()):
 121             self.nc_type = NCType.schema
 122         elif self.nc_dnstr == str(samdb.get_config_basedn()):
 123             self.nc_type = NCType.config
 124         elif self.nc_sid is not None:
 125             self.nc_type = NCType.domain
 126         else:
 127             self.nc_type = NCType.application
 128
 129     def identify_by_dsa_attr(self, samdb, attr):
 130         """Given an NC which has been discovered thru the
 131         nTDSDSA database object, determine what type of NC
 132         it is (i.e. schema, config, domain, application) via
 133         the use of the schema attribute under which the NC
 134         was found.
 135
 136         :param attr: attr of nTDSDSA object where NC DN appears
 137         """
 138         # If the NC is listed under msDS-HasDomainNCs then
 139         # this can only be a domain NC and it is our default
 140         # domain for this dsa
 141         if attr == "msDS-HasDomainNCs":
 142             self.nc_type = NCType.domain
 143
 144         # If the NC is listed under hasPartialReplicaNCs
 145         # this is only a domain NC
 146         elif attr == "hasPartialReplicaNCs":
 147             self.nc_type = NCType.domain
 148
 149         # NCs listed under hasMasterNCs are either
 150         # default domain, schema, or config.  We
 151         # utilize the identify_by_basedn() to
 152         # identify those
 153         elif attr == "hasMasterNCs":
 154             self.identify_by_basedn(samdb)
 155
 156         # Still unknown (unlikely) but for completeness
 157         # and for finally identifying application NCs
 158         if self.nc_type == NCType.unknown:
 159             self.identify_by_basedn(samdb)
 160
 161
 162 class NCReplica(NamingContext):
 163     """Naming context replica that is relative to a specific DSA.
 164
 165     This is a more specific form of NamingContext class (inheriting from that
 166     class) and it identifies unique attributes of the DSA's replica for a NC.
 167     """
 168
 169     def __init__(self, dsa, nc_dnstr):
 170         """Instantiate a Naming Context Replica
 171
 172         :param dsa_guid: GUID of DSA where replica appears
 173         :param nc_dnstr: NC dn string
 174         """
 175         self.rep_dsa_dnstr = dsa.dsa_dnstr
 176         self.rep_dsa_guid = dsa.dsa_guid
 177         self.rep_default = False  # replica for DSA's default domain
 178         self.rep_partial = False
 179         self.rep_ro = False
 180         self.rep_instantiated_flags = 0
 181
 182         self.rep_fsmo_role_owner = None
 183
 184         # RepsFromTo tuples
 185         self.rep_repsFrom = []
 186
 187         # RepsFromTo tuples
 188         self.rep_repsTo = []
 189
 190         # The (is present) test is a combination of being
 191         # enumerated in (hasMasterNCs or msDS-hasFullReplicaNCs or
 192         # hasPartialReplicaNCs) as well as its replica flags found
 193         # thru the msDS-HasInstantiatedNCs.  If the NC replica meets
 194         # the first enumeration test then this flag is set true
 195         self.rep_present_criteria_one = False
 196
 197         # Call my super class we inherited from
 198         NamingContext.__init__(self, nc_dnstr)
 199
 200     def __str__(self):
 201         '''Debug dump string output of class'''
 202         text = "%s:" % self.__class__.__name__
 203         text = text + "\n\tdsa_dnstr=%s" % self.rep_dsa_dnstr
 204         text = text + "\n\tdsa_guid=%s" % self.rep_dsa_guid
 205         text = text + "\n\tdefault=%s" % self.rep_default
 206         text = text + "\n\tro=%s" % self.rep_ro
 207         text = text + "\n\tpartial=%s" % self.rep_partial
 208         text = text + "\n\tpresent=%s" % self.is_present()
 209         text = text + "\n\tfsmo_role_owner=%s" % self.rep_fsmo_role_owner
 210
 211         for rep in self.rep_repsFrom:
 212             text = text + "\n%s" % rep
 213
 214         for rep in self.rep_repsTo:
 215             text = text + "\n%s" % rep
 216
 217         return "%s\n%s" % (NamingContext.__str__(self), text)
 218
 219     def set_instantiated_flags(self, flags=0):
 220         '''Set or clear NC replica instantiated flags'''
 221         self.rep_instantiated_flags = flags
 222
 223     def identify_by_dsa_attr(self, samdb, attr):
 224         """Given an NC which has been discovered thru the
 225         nTDSDSA database object, determine what type of NC
 226         replica it is (i.e. partial, read only, default)
 227
 228         :param attr: attr of nTDSDSA object where NC DN appears
 229         """
 230         # If the NC was found under hasPartialReplicaNCs
 231         # then a partial replica at this dsa
 232         if attr == "hasPartialReplicaNCs":
 233             self.rep_partial = True
 234             self.rep_present_criteria_one = True
 235
 236         # If the NC is listed under msDS-HasDomainNCs then
 237         # this can only be a domain NC and it is the DSA's
 238         # default domain NC
 239         elif attr == "msDS-HasDomainNCs":
 240             self.rep_default = True
 241
 242         # NCs listed under hasMasterNCs are either
 243         # default domain, schema, or config.  We check
 244         # against schema and config because they will be
 245         # the same for all nTDSDSAs in the forest.  That
 246         # leaves the default domain NC remaining which
 247         # may be different for each nTDSDSAs (and thus
 248         # we don't compare agains this samdb's default
 249         # basedn
 250         elif attr == "hasMasterNCs":
 251             self.rep_present_criteria_one = True
 252
 253             if self.nc_dnstr != str(samdb.get_schema_basedn()) and \
 254                self.nc_dnstr != str(samdb.get_config_basedn()):
 255                 self.rep_default = True
 256
 257         # RODC only
 258         elif attr == "msDS-hasFullReplicaNCs":
 259             self.rep_present_criteria_one = True
 260             self.rep_ro = True
 261
 262         # Not RODC
 263         elif attr == "msDS-hasMasterNCs":
 264             self.rep_present_criteria_one = True
 265             self.rep_ro = False
 266
 267         # Now use this DSA attribute to identify the naming
 268         # context type by calling the super class method
 269         # of the same name
 270         NamingContext.identify_by_dsa_attr(self, samdb, attr)
 271
 272     def is_default(self):
 273         """Whether this is a default domain for the dsa that this NC appears on
 274         """
 275         return self.rep_default
 276
 277     def is_ro(self):
 278         '''Return True if NC replica is read only'''
 279         return self.rep_ro
 280
 281     def is_partial(self):
 282         '''Return True if NC replica is partial'''
 283         return self.rep_partial
 284
 285     def is_present(self):
 286         """Given an NC replica which has been discovered thru the
 287         nTDSDSA database object and populated with replica flags
 288         from the msDS-HasInstantiatedNCs; return whether the NC
 289         replica is present (true) or if the IT_NC_GOING flag is
 290         set then the NC replica is not present (false)
 291         """
 292         if self.rep_present_criteria_one and \
 293            self.rep_instantiated_flags & dsdb.INSTANCE_TYPE_NC_GOING == 0:
 294             return True
 295         return False
 296
 297     def load_repsFrom(self, samdb):
 298         """Given an NC replica which has been discovered thru the nTDSDSA
 299         database object, load the repsFrom attribute for the local replica.
 300         held by my dsa.  The repsFrom attribute is not replicated so this
 301         attribute is relative only to the local DSA that the samdb exists on
 302         """
 303         try:
 304             res = samdb.search(base=self.nc_dnstr, scope=ldb.SCOPE_BASE,
 305                                attrs=["repsFrom"])
 306
 307         except ldb.LdbError as e1:
 308             (enum, estr) = e1.args
 309             raise KCCError("Unable to find NC for (%s) - (%s)" %
 310                            (self.nc_dnstr, estr))
 311
 312         msg = res[0]
 313
 314         # Possibly no repsFrom if this is a singleton DC
 315         if "repsFrom" in msg:
 316             for value in msg["repsFrom"]:
 317                 rep = RepsFromTo(self.nc_dnstr,
 318                                  ndr_unpack(drsblobs.repsFromToBlob, value))
 319                 self.rep_repsFrom.append(rep)
 320
 321     def commit_repsFrom(self, samdb, ro=False):
 322         """Commit repsFrom to the database"""
 323
 324         # XXX - This is not truly correct according to the MS-TECH
 325         #       docs.  To commit a repsFrom we should be using RPCs
 326         #       IDL_DRSReplicaAdd, IDL_DRSReplicaModify, and
 327         #       IDL_DRSReplicaDel to affect a repsFrom change.
 328         #
 329         #       Those RPCs are missing in samba, so I'll have to
 330         #       implement them to get this to more accurately
 331         #       reflect the reference docs.  As of right now this
 332         #       commit to the database will work as its what the
 333         #       older KCC also did
 334         modify = False
 335         newreps = []
 336         delreps = []
 337
 338         for repsFrom in self.rep_repsFrom:
 339
 340             # Leave out any to be deleted from
 341             # replacement list.  Build a list
 342             # of to be deleted reps which we will
 343             # remove from rep_repsFrom list below
 344             if repsFrom.to_be_deleted:
 345                 delreps.append(repsFrom)
 346                 modify = True
 347                 continue
 348
 349             if repsFrom.is_modified():
 350                 repsFrom.set_unmodified()
 351                 modify = True
 352
 353             # current (unmodified) elements also get
 354             # appended here but no changes will occur
 355             # unless something is "to be modified" or
 356             # "to be deleted"
 357             newreps.append(ndr_pack(repsFrom.ndr_blob))
 358
 359         # Now delete these from our list of rep_repsFrom
 360         for repsFrom in delreps:
 361             self.rep_repsFrom.remove(repsFrom)
 362         delreps = []
 363
 364         # Nothing to do if no reps have been modified or
 365         # need to be deleted or input option has informed
 366         # us to be "readonly" (ro).  Leave database
 367         # record "as is"
 368         if not modify or ro:
 369             return
 370
 371         m = ldb.Message()
 372         m.dn = ldb.Dn(samdb, self.nc_dnstr)
 373
 374         m["repsFrom"] = \
 375             ldb.MessageElement(newreps, ldb.FLAG_MOD_REPLACE, "repsFrom")
 376
 377         try:
 378             samdb.modify(m)
 379
 380         except ldb.LdbError as estr:
 381             raise KCCError("Could not set repsFrom for (%s) - (%s)" %
 382                            (self.nc_dnstr, estr))
 383
 384     def load_replUpToDateVector(self, samdb):
 385         """Given an NC replica which has been discovered thru the nTDSDSA
 386         database object, load the replUpToDateVector attribute for the
 387         local replica. held by my dsa. The replUpToDateVector
 388         attribute is not replicated so this attribute is relative only
 389         to the local DSA that the samdb exists on
 390
 391         """
 392         try:
 393             res = samdb.search(base=self.nc_dnstr, scope=ldb.SCOPE_BASE,
 394                                attrs=["replUpToDateVector"])
 395
 396         except ldb.LdbError as e2:
 397             (enum, estr) = e2.args
 398             raise KCCError("Unable to find NC for (%s) - (%s)" %
 399                            (self.nc_dnstr, estr))
 400
 401         msg = res[0]
 402
 403         # Possibly no replUpToDateVector if this is a singleton DC
 404         if "replUpToDateVector" in msg:
 405             value = msg["replUpToDateVector"][0]
 406             blob = ndr_unpack(drsblobs.replUpToDateVectorBlob,
 407                               value)
 408             if blob.version != 2:
 409                 # Samba only generates version 2, and this runs locally
 410                 raise AttributeError("Unexpected replUpToDateVector version %d"
 411                                      % blob.version)
 412
 413             self.rep_replUpToDateVector_cursors = blob.ctr.cursors
 414         else:
 415             self.rep_replUpToDateVector_cursors = []
 416
 417     def dumpstr_to_be_deleted(self):
 418         return '\n'.join(str(x) for x in self.rep_repsFrom if x.to_be_deleted)
 419
 420     def dumpstr_to_be_modified(self):
 421         return '\n'.join(str(x) for x in self.rep_repsFrom if x.is_modified())
 422
 423     def load_fsmo_roles(self, samdb):
 424         """Given an NC replica which has been discovered thru the nTDSDSA
 425         database object, load the fSMORoleOwner attribute.
 426         """
 427         try:
 428             res = samdb.search(base=self.nc_dnstr, scope=ldb.SCOPE_BASE,
 429                                attrs=["fSMORoleOwner"])
 430
 431         except ldb.LdbError as e3:
 432             (enum, estr) = e3.args
 433             raise KCCError("Unable to find NC for (%s) - (%s)" %
 434                            (self.nc_dnstr, estr))
 435
 436         msg = res[0]
 437
 438         # Possibly no fSMORoleOwner
 439         if "fSMORoleOwner" in msg:
 440             self.rep_fsmo_role_owner = msg["fSMORoleOwner"]
 441
 442     def is_fsmo_role_owner(self, dsa_dnstr):
 443         if self.rep_fsmo_role_owner is not None and \
 444            self.rep_fsmo_role_owner == dsa_dnstr:
 445             return True
 446         return False
 447
 448     def load_repsTo(self, samdb):
 449         """Given an NC replica which has been discovered thru the nTDSDSA
 450         database object, load the repsTo attribute for the local replica.
 451         held by my dsa.  The repsTo attribute is not replicated so this
 452         attribute is relative only to the local DSA that the samdb exists on
 453
 454         This is responsible for push replication, not scheduled pull
 455         replication. Not to be confused for repsFrom.
 456         """
 457         try:
 458             res = samdb.search(base=self.nc_dnstr, scope=ldb.SCOPE_BASE,
 459                                attrs=["repsTo"])
 460
 461         except ldb.LdbError as e4:
 462             (enum, estr) = e4.args
 463             raise KCCError("Unable to find NC for (%s) - (%s)" %
 464                            (self.nc_dnstr, estr))
 465
 466         msg = res[0]
 467
 468         # Possibly no repsTo if this is a singleton DC
 469         if "repsTo" in msg:
 470             for value in msg["repsTo"]:
 471                 rep = RepsFromTo(self.nc_dnstr,
 472                                  ndr_unpack(drsblobs.repsFromToBlob, value))
 473                 self.rep_repsTo.append(rep)
 474
 475     def commit_repsTo(self, samdb, ro=False):
 476         """Commit repsTo to the database"""
 477
 478         # XXX - This is not truly correct according to the MS-TECH
 479         #       docs.  To commit a repsTo we should be using RPCs
 480         #       IDL_DRSReplicaAdd, IDL_DRSReplicaModify, and
 481         #       IDL_DRSReplicaDel to affect a repsTo change.
 482         #
 483         #       Those RPCs are missing in samba, so I'll have to
 484         #       implement them to get this to more accurately
 485         #       reflect the reference docs.  As of right now this
 486         #       commit to the database will work as its what the
 487         #       older KCC also did
 488         modify = False
 489         newreps = []
 490         delreps = []
 491
 492         for repsTo in self.rep_repsTo:
 493
 494             # Leave out any to be deleted from
 495             # replacement list.  Build a list
 496             # of to be deleted reps which we will
 497             # remove from rep_repsTo list below
 498             if repsTo.to_be_deleted:
 499                 delreps.append(repsTo)
 500                 modify = True
 501                 continue
 502
 503             if repsTo.is_modified():
 504                 repsTo.set_unmodified()
 505                 modify = True
 506
 507             # current (unmodified) elements also get
 508             # appended here but no changes will occur
 509             # unless something is "to be modified" or
 510             # "to be deleted"
 511             newreps.append(ndr_pack(repsTo.ndr_blob))
 512
 513         # Now delete these from our list of rep_repsTo
 514         for repsTo in delreps:
 515             self.rep_repsTo.remove(repsTo)
 516         delreps = []
 517
 518         # Nothing to do if no reps have been modified or
 519         # need to be deleted or input option has informed
 520         # us to be "readonly" (ro).  Leave database
 521         # record "as is"
 522         if not modify or ro:
 523             return
 524
 525         m = ldb.Message()
 526         m.dn = ldb.Dn(samdb, self.nc_dnstr)
 527
 528         m["repsTo"] = \
 529             ldb.MessageElement(newreps, ldb.FLAG_MOD_REPLACE, "repsTo")
 530
 531         try:
 532             samdb.modify(m)
 533
 534         except ldb.LdbError as estr:
 535             raise KCCError("Could not set repsTo for (%s) - (%s)" %
 536                            (self.nc_dnstr, estr))
 537
 538
 539 class DirectoryServiceAgent(object):
 540
 541     def __init__(self, dsa_dnstr):
 542         """Initialize DSA class.
 543
 544         Class is subsequently fully populated by calling the load_dsa() method
 545
 546         :param dsa_dnstr:  DN of the nTDSDSA
 547         """
 548         self.dsa_dnstr = dsa_dnstr
 549         self.dsa_guid = None
 550         self.dsa_ivid = None
 551         self.dsa_is_ro = False
 552         self.dsa_is_istg = False
 553         self.options = 0
 554         self.dsa_behavior = 0
 555         self.default_dnstr = None  # default domain dn string for dsa
 556
 557         # NCReplicas for this dsa that are "present"
 558         # Indexed by DN string of naming context
 559         self.current_rep_table = {}
 560
 561         # NCReplicas for this dsa that "should be present"
 562         # Indexed by DN string of naming context
 563         self.needed_rep_table = {}
 564
 565         # NTDSConnections for this dsa.  These are current
 566         # valid connections that are committed or pending a commit
 567         # in the database.  Indexed by DN string of connection
 568         self.connect_table = {}
 569
 570     def __str__(self):
 571         '''Debug dump string output of class'''
 572
 573         text = "%s:" % self.__class__.__name__
 574         if self.dsa_dnstr is not None:
 575             text = text + "\n\tdsa_dnstr=%s" % self.dsa_dnstr
 576         if self.dsa_guid is not None:
 577             text = text + "\n\tdsa_guid=%s" % str(self.dsa_guid)
 578         if self.dsa_ivid is not None:
 579             text = text + "\n\tdsa_ivid=%s" % str(self.dsa_ivid)
 580
 581         text = text + "\n\tro=%s" % self.is_ro()
 582         text = text + "\n\tgc=%s" % self.is_gc()
 583         text = text + "\n\tistg=%s" % self.is_istg()
 584
 585         text = text + "\ncurrent_replica_table:"
 586         text = text + "\n%s" % self.dumpstr_current_replica_table()
 587         text = text + "\nneeded_replica_table:"
 588         text = text + "\n%s" % self.dumpstr_needed_replica_table()
 589         text = text + "\nconnect_table:"
 590         text = text + "\n%s" % self.dumpstr_connect_table()
 591
 592         return text
 593
 594     def get_current_replica(self, nc_dnstr):
 595         return self.current_rep_table.get(nc_dnstr)
 596
 597     def is_istg(self):
 598         '''Returns True if dsa is intersite topology generator for it's site'''
 599         # The KCC on an RODC always acts as an ISTG for itself
 600         return self.dsa_is_istg or self.dsa_is_ro
 601
 602     def is_ro(self):
 603         '''Returns True if dsa a read only domain controller'''
 604         return self.dsa_is_ro
 605
 606     def is_gc(self):
 607         '''Returns True if dsa hosts a global catalog'''
 608         if (self.options & dsdb.DS_NTDSDSA_OPT_IS_GC) != 0:
 609             return True
 610         return False
 611
 612     def is_minimum_behavior(self, version):
 613         """Is dsa at minimum windows level greater than or equal to (version)
 614
 615         :param version: Windows version to test against
 616             (e.g. DS_DOMAIN_FUNCTION_2008)
 617         """
 618         if self.dsa_behavior >= version:
 619             return True
 620         return False
 621
 622     def is_translate_ntdsconn_disabled(self):
 623         """Whether this allows NTDSConnection translation in its options."""
 624         if (self.options & dsdb.DS_NTDSDSA_OPT_DISABLE_NTDSCONN_XLATE) != 0:
 625             return True
 626         return False
 627
 628     def get_rep_tables(self):
 629         """Return DSA current and needed replica tables
 630         """
 631         return self.current_rep_table, self.needed_rep_table
 632
 633     def get_parent_dnstr(self):
 634         """Get the parent DN string of this object."""
 635         head, sep, tail = self.dsa_dnstr.partition(',')
 636         return tail
 637
 638     def load_dsa(self, samdb):
 639         """Load a DSA from the samdb.
 640
 641         Prior initialization has given us the DN of the DSA that we are to
 642         load.  This method initializes all other attributes, including loading
 643         the NC replica table for this DSA.
 644         """
 645         attrs = ["objectGUID",
 646                  "invocationID",
 647                  "options",
 648                  "msDS-isRODC",
 649                  "msDS-Behavior-Version"]
 650         try:
 651             res = samdb.search(base=self.dsa_dnstr, scope=ldb.SCOPE_BASE,
 652                                attrs=attrs)
 653
 654         except ldb.LdbError as e5:
 655             (enum, estr) = e5.args
 656             raise KCCError("Unable to find nTDSDSA for (%s) - (%s)" %
 657                            (self.dsa_dnstr, estr))
 658
 659         msg = res[0]
 660         self.dsa_guid = misc.GUID(samdb.schema_format_value("objectGUID",
 661                                   msg["objectGUID"][0]))
 662
 663         # RODCs don't originate changes and thus have no invocationId,
 664         # therefore we must check for existence first
 665         if "invocationId" in msg:
 666             self.dsa_ivid = misc.GUID(samdb.schema_format_value("objectGUID",
 667                                       msg["invocationId"][0]))
 668
 669         if "options" in msg:
 670             self.options = int(msg["options"][0])
 671
 672         if "msDS-isRODC" in msg and msg["msDS-isRODC"][0] == "TRUE":
 673             self.dsa_is_ro = True
 674         else:
 675             self.dsa_is_ro = False
 676
 677         if "msDS-Behavior-Version" in msg:
 678             self.dsa_behavior = int(msg['msDS-Behavior-Version'][0])
 679
 680         # Load the NC replicas that are enumerated on this dsa
 681         self.load_current_replica_table(samdb)
 682
 683         # Load the nTDSConnection that are enumerated on this dsa
 684         self.load_connection_table(samdb)
 685
 686     def load_current_replica_table(self, samdb):
 687         """Method to load the NC replica's listed for DSA object.
 688
 689         This method queries the samdb for (hasMasterNCs, msDS-hasMasterNCs,
 690         hasPartialReplicaNCs, msDS-HasDomainNCs, msDS-hasFullReplicaNCs, and
 691         msDS-HasInstantiatedNCs) to determine complete list of NC replicas that
 692         are enumerated for the DSA.  Once a NC replica is loaded it is
 693         identified (schema, config, etc) and the other replica attributes
 694         (partial, ro, etc) are determined.
 695
 696         :param samdb: database to query for DSA replica list
 697         """
 698         ncattrs = [
 699             # not RODC - default, config, schema (old style)
 700             "hasMasterNCs",
 701             # not RODC - default, config, schema, app NCs
 702             "msDS-hasMasterNCs",
 703             # domain NC partial replicas
 704             "hasPartialReplicaNCs",
 705             # default domain NC
 706             "msDS-HasDomainNCs",
 707             # RODC only - default, config, schema, app NCs
 708             "msDS-hasFullReplicaNCs",
 709             # Identifies if replica is coming, going, or stable
 710             "msDS-HasInstantiatedNCs"
 711         ]
 712         try:
 713             res = samdb.search(base=self.dsa_dnstr, scope=ldb.SCOPE_BASE,
 714                                attrs=ncattrs)
 715
 716         except ldb.LdbError as e6:
 717             (enum, estr) = e6.args
 718             raise KCCError("Unable to find nTDSDSA NCs for (%s) - (%s)" %
 719                            (self.dsa_dnstr, estr))
 720
 721         # The table of NCs for the dsa we are searching
 722         tmp_table = {}
 723
 724         # We should get one response to our query here for
 725         # the ntds that we requested
 726         if len(res[0]) > 0:
 727
 728             # Our response will contain a number of elements including
 729             # the dn of the dsa as well as elements for each
 730             # attribute (e.g. hasMasterNCs).  Each of these elements
 731             # is a dictonary list which we retrieve the keys for and
 732             # then iterate over them
 733             for k in res[0].keys():
 734                 if k == "dn":
 735                     continue
 736
 737                 # For each attribute type there will be one or more DNs
 738                 # listed.  For instance DCs normally have 3 hasMasterNCs
 739                 # listed.
 740                 for value in res[0][k]:
 741                     # Turn dn into a dsdb_Dn so we can use
 742                     # its methods to parse a binary DN
 743                     dsdn = dsdb_Dn(samdb, value.decode('utf8'))
 744                     flags = dsdn.get_binary_integer()
 745                     dnstr = str(dsdn.dn)
 746
 747                     if dnstr not in tmp_table:
 748                         rep = NCReplica(self, dnstr)
 749                         tmp_table[dnstr] = rep
 750                     else:
 751                         rep = tmp_table[dnstr]
 752
 753                     if k == "msDS-HasInstantiatedNCs":
 754                         rep.set_instantiated_flags(flags)
 755                         continue
 756
 757                     rep.identify_by_dsa_attr(samdb, k)
 758
 759                     # if we've identified the default domain NC
 760                     # then save its DN string
 761                     if rep.is_default():
 762                         self.default_dnstr = dnstr
 763         else:
 764             raise KCCError("No nTDSDSA NCs for (%s)" % self.dsa_dnstr)
 765
 766         # Assign our newly built NC replica table to this dsa
 767         self.current_rep_table = tmp_table
 768
 769     def add_needed_replica(self, rep):
 770         """Method to add a NC replica that "should be present" to the
 771         needed_rep_table.
 772         """
 773         self.needed_rep_table[rep.nc_dnstr] = rep
 774
 775     def load_connection_table(self, samdb):
 776         """Method to load the nTDSConnections listed for DSA object.
 777
 778         :param samdb: database to query for DSA connection list
 779         """
 780         try:
 781             res = samdb.search(base=self.dsa_dnstr,
 782                                scope=ldb.SCOPE_SUBTREE,
 783                                expression="(objectClass=nTDSConnection)")
 784
 785         except ldb.LdbError as e7:
 786             (enum, estr) = e7.args
 787             raise KCCError("Unable to find nTDSConnection for (%s) - (%s)" %
 788                            (self.dsa_dnstr, estr))
 789
 790         for msg in res:
 791             dnstr = str(msg.dn)
 792
 793             # already loaded
 794             if dnstr in self.connect_table:
 795                 continue
 796
 797             connect = NTDSConnection(dnstr)
 798
 799             connect.load_connection(samdb)
 800             self.connect_table[dnstr] = connect
 801
 802     def commit_connections(self, samdb, ro=False):
 803         """Method to commit any uncommitted nTDSConnections
 804         modifications that are in our table.  These would be
 805         identified connections that are marked to be added or
 806         deleted
 807
 808         :param samdb: database to commit DSA connection list to
 809         :param ro: if (true) then peform internal operations but
 810             do not write to the database (readonly)
 811         """
 812         delconn = []
 813
 814         for dnstr, connect in self.connect_table.items():
 815             if connect.to_be_added:
 816                 connect.commit_added(samdb, ro)
 817
 818             if connect.to_be_modified:
 819                 connect.commit_modified(samdb, ro)
 820
 821             if connect.to_be_deleted:
 822                 connect.commit_deleted(samdb, ro)
 823                 delconn.append(dnstr)
 824
 825         # Now delete the connection from the table
 826         for dnstr in delconn:
 827             del self.connect_table[dnstr]
 828
 829     def add_connection(self, dnstr, connect):
 830         assert dnstr not in self.connect_table
 831         self.connect_table[dnstr] = connect
 832
 833     def get_connection_by_from_dnstr(self, from_dnstr):
 834         """Scan DSA nTDSConnection table and return connection
 835         with a "fromServer" dn string equivalent to method
 836         input parameter.
 837
 838         :param from_dnstr: search for this from server entry
 839         """
 840         answer = []
 841         for connect in self.connect_table.values():
 842             if connect.get_from_dnstr() == from_dnstr:
 843                 answer.append(connect)
 844
 845         return answer
 846
 847     def dumpstr_current_replica_table(self):
 848         '''Debug dump string output of current replica table'''
 849         return '\n'.join(str(x) for x in self.current_rep_table)
 850
 851     def dumpstr_needed_replica_table(self):
 852         '''Debug dump string output of needed replica table'''
 853         return '\n'.join(str(x) for x in self.needed_rep_table)
 854
 855     def dumpstr_connect_table(self):
 856         '''Debug dump string output of connect table'''
 857         return '\n'.join(str(x) for x in self.connect_table)
 858
 859     def new_connection(self, options, system_flags, transport, from_dnstr,
 860                        sched):
 861         """Set up a new connection for the DSA based on input
 862         parameters.  Connection will be added to the DSA
 863         connect_table and will be marked as "to be added" pending
 864         a call to commit_connections()
 865         """
 866         dnstr = "CN=%s," % str(uuid.uuid4()) + self.dsa_dnstr
 867
 868         connect = NTDSConnection(dnstr)
 869         connect.to_be_added = True
 870         connect.enabled = True
 871         connect.from_dnstr = from_dnstr
 872         connect.options = options
 873         connect.system_flags = system_flags
 874
 875         if transport is not None:
 876             connect.transport_dnstr = transport.dnstr
 877             connect.transport_guid = transport.guid
 878
 879         if sched is not None:
 880             connect.schedule = sched
 881         else:
 882             # Create schedule.  Attribute valuse set according to MS-TECH
 883             # intrasite connection creation document
 884             connect.schedule = new_connection_schedule()
 885
 886         self.add_connection(dnstr, connect)
 887         return connect
 888
 889
 890 class NTDSConnection(object):
 891     """Class defines a nTDSConnection found under a DSA
 892     """
 893     def __init__(self, dnstr):
 894         self.dnstr = dnstr
 895         self.guid = None
 896         self.enabled = False
 897         self.whenCreated = 0
 898         self.to_be_added = False  # new connection needs to be added
 899         self.to_be_deleted = False  # old connection needs to be deleted
 900         self.to_be_modified = False
 901         self.options = 0
 902         self.system_flags = 0
 903         self.transport_dnstr = None
 904         self.transport_guid = None
 905         self.from_dnstr = None
 906         self.schedule = None
 907
 908     def __str__(self):
 909         '''Debug dump string output of NTDSConnection object'''
 910
 911         text = "%s:\n\tdn=%s" % (self.__class__.__name__, self.dnstr)
 912         text = text + "\n\tenabled=%s" % self.enabled
 913         text = text + "\n\tto_be_added=%s" % self.to_be_added
 914         text = text + "\n\tto_be_deleted=%s" % self.to_be_deleted
 915         text = text + "\n\tto_be_modified=%s" % self.to_be_modified
 916         text = text + "\n\toptions=0x%08X" % self.options
 917         text = text + "\n\tsystem_flags=0x%08X" % self.system_flags
 918         text = text + "\n\twhenCreated=%d" % self.whenCreated
 919         text = text + "\n\ttransport_dn=%s" % self.transport_dnstr
 920
 921         if self.guid is not None:
 922             text = text + "\n\tguid=%s" % str(self.guid)
 923
 924         if self.transport_guid is not None:
 925             text = text + "\n\ttransport_guid=%s" % str(self.transport_guid)
 926
 927         text = text + "\n\tfrom_dn=%s" % self.from_dnstr
 928
 929         if self.schedule is not None:
 930             text += "\n\tschedule.size=%s" % self.schedule.size
 931             text += "\n\tschedule.bandwidth=%s" % self.schedule.bandwidth
 932             text += ("\n\tschedule.numberOfSchedules=%s" %
 933                      self.schedule.numberOfSchedules)
 934
 935             for i, header in enumerate(self.schedule.headerArray):
 936                 text += ("\n\tschedule.headerArray[%d].type=%d" %
 937                          (i, header.type))
 938                 text += ("\n\tschedule.headerArray[%d].offset=%d" %
 939                          (i, header.offset))
 940                 text += "\n\tschedule.dataArray[%d].slots[ " % i
 941                 for slot in self.schedule.dataArray[i].slots:
 942                     text = text + "0x%X " % slot
 943                 text = text + "]"
 944
 945         return text
 946
 947     def load_connection(self, samdb):
 948         """Given a NTDSConnection object with an prior initialization
 949         for the object's DN, search for the DN and load attributes
 950         from the samdb.
 951         """
 952         attrs = ["options",
 953                  "enabledConnection",
 954                  "schedule",
 955                  "whenCreated",
 956                  "objectGUID",
 957                  "transportType",
 958                  "fromServer",
 959                  "systemFlags"]
 960         try:
 961             res = samdb.search(base=self.dnstr, scope=ldb.SCOPE_BASE,
 962                                attrs=attrs)
 963
 964         except ldb.LdbError as e8:
 965             (enum, estr) = e8.args
 966             raise KCCError("Unable to find nTDSConnection for (%s) - (%s)" %
 967                            (self.dnstr, estr))
 968
 969         msg = res[0]
 970
 971         if "options" in msg:
 972             self.options = int(msg["options"][0])
 973
 974         if "enabledConnection" in msg:
 975             if msg["enabledConnection"][0].upper().lstrip().rstrip() == "TRUE":
 976                 self.enabled = True
 977
 978         if "systemFlags" in msg:
 979             self.system_flags = int(msg["systemFlags"][0])
 980
 981         try:
 982             self.guid = \
 983                 misc.GUID(samdb.schema_format_value("objectGUID",
 984                                                     msg["objectGUID"][0]))
 985         except KeyError:
 986             raise KCCError("Unable to find objectGUID in nTDSConnection "
 987                            "for (%s)" % (self.dnstr))
 988
 989         if "transportType" in msg:
 990             dsdn = dsdb_Dn(samdb, msg["transportType"][0].decode('utf8'))
 991             self.load_connection_transport(samdb, str(dsdn.dn))
 992
 993         if "schedule" in msg:
 994             self.schedule = ndr_unpack(drsblobs.schedule, msg["schedule"][0])
 995
 996         if "whenCreated" in msg:
 997             self.whenCreated = ldb.string_to_time(msg["whenCreated"][0])
 998
 999         if "fromServer" in msg:
1000             dsdn = dsdb_Dn(samdb, msg["fromServer"][0].decode('utf8'))
1001             self.from_dnstr = str(dsdn.dn)
1002             assert self.from_dnstr is not None
1003
1004     def load_connection_transport(self, samdb, tdnstr):
1005         """Given a NTDSConnection object which enumerates a transport
1006         DN, load the transport information for the connection object
1007
1008         :param tdnstr: transport DN to load
1009         """
1010         attrs = ["objectGUID"]
1011         try:
1012             res = samdb.search(base=tdnstr,
1013                                scope=ldb.SCOPE_BASE, attrs=attrs)
1014
1015         except ldb.LdbError as e9:
1016             (enum, estr) = e9.args
1017             raise KCCError("Unable to find transport (%s) - (%s)" %
1018                            (tdnstr, estr))
1019
1020         if "objectGUID" in res[0]:
1021             msg = res[0]
1022             self.transport_dnstr = tdnstr
1023             self.transport_guid = \
1024                 misc.GUID(samdb.schema_format_value("objectGUID",
1025                                                     msg["objectGUID"][0]))
1026         assert self.transport_dnstr is not None
1027         assert self.transport_guid is not None
1028
1029     def commit_deleted(self, samdb, ro=False):
1030         """Local helper routine for commit_connections() which
1031         handles committed connections that are to be deleted from
1032         the database database
1033         """
1034         assert self.to_be_deleted
1035         self.to_be_deleted = False
1036
1037         # No database modification requested
1038         if ro:
1039             return
1040
1041         try:
1042             samdb.delete(self.dnstr)
1043         except ldb.LdbError as e10:
1044             (enum, estr) = e10.args
1045             raise KCCError("Could not delete nTDSConnection for (%s) - (%s)" %
1046                            (self.dnstr, estr))
1047
1048     def commit_added(self, samdb, ro=False):
1049         """Local helper routine for commit_connections() which
1050         handles committed connections that are to be added to the
1051         database
1052         """
1053         assert self.to_be_added
1054         self.to_be_added = False
1055
1056         # No database modification requested
1057         if ro:
1058             return
1059
1060         # First verify we don't have this entry to ensure nothing
1061         # is programatically amiss
1062         found = False
1063         try:
1064             msg = samdb.search(base=self.dnstr, scope=ldb.SCOPE_BASE)
1065             if len(msg) != 0:
1066                 found = True
1067
1068         except ldb.LdbError as e11:
1069             (enum, estr) = e11.args
1070             if enum != ldb.ERR_NO_SUCH_OBJECT:
1071                 raise KCCError("Unable to search for (%s) - (%s)" %
1072                                (self.dnstr, estr))
1073         if found:
1074             raise KCCError("nTDSConnection for (%s) already exists!" %
1075                            self.dnstr)
1076
1077         if self.enabled:
1078             enablestr = "TRUE"
1079         else:
1080             enablestr = "FALSE"
1081
1082         # Prepare a message for adding to the samdb
1083         m = ldb.Message()
1084         m.dn = ldb.Dn(samdb, self.dnstr)
1085
1086         m["objectClass"] = \
1087             ldb.MessageElement("nTDSConnection", ldb.FLAG_MOD_ADD,
1088                                "objectClass")
1089         m["showInAdvancedViewOnly"] = \
1090             ldb.MessageElement("TRUE", ldb.FLAG_MOD_ADD,
1091                                "showInAdvancedViewOnly")
1092         m["enabledConnection"] = \
1093             ldb.MessageElement(enablestr, ldb.FLAG_MOD_ADD,
1094                                "enabledConnection")
1095         m["fromServer"] = \
1096             ldb.MessageElement(self.from_dnstr, ldb.FLAG_MOD_ADD, "fromServer")
1097         m["options"] = \
1098             ldb.MessageElement(str(self.options), ldb.FLAG_MOD_ADD, "options")
1099         m["systemFlags"] = \
1100             ldb.MessageElement(str(self.system_flags), ldb.FLAG_MOD_ADD,
1101                                "systemFlags")
1102
1103         if self.transport_dnstr is not None:
1104             m["transportType"] = \
1105                 ldb.MessageElement(str(self.transport_dnstr), ldb.FLAG_MOD_ADD,
1106                                    "transportType")
1107
1108         if self.schedule is not None:
1109             m["schedule"] = \
1110                 ldb.MessageElement(ndr_pack(self.schedule),
1111                                    ldb.FLAG_MOD_ADD, "schedule")
1112         try:
1113             samdb.add(m)
1114         except ldb.LdbError as e12:
1115             (enum, estr) = e12.args
1116             raise KCCError("Could not add nTDSConnection for (%s) - (%s)" %
1117                            (self.dnstr, estr))
1118
1119     def commit_modified(self, samdb, ro=False):
1120         """Local helper routine for commit_connections() which
1121         handles committed connections that are to be modified to the
1122         database
1123         """
1124         assert self.to_be_modified
1125         self.to_be_modified = False
1126
1127         # No database modification requested
1128         if ro:
1129             return
1130
1131         # First verify we have this entry to ensure nothing
1132         # is programatically amiss
1133         try:
1134             # we don't use the search result, but it tests the status
1135             # of self.dnstr in the database.
1136             samdb.search(base=self.dnstr, scope=ldb.SCOPE_BASE)
1137
1138         except ldb.LdbError as e13:
1139             (enum, estr) = e13.args
1140             if enum == ldb.ERR_NO_SUCH_OBJECT:
1141                 raise KCCError("nTDSConnection for (%s) doesn't exist!" %
1142                                self.dnstr)
1143             raise KCCError("Unable to search for (%s) - (%s)" %
1144                            (self.dnstr, estr))
1145
1146         if self.enabled:
1147             enablestr = "TRUE"
1148         else:
1149             enablestr = "FALSE"
1150
1151         # Prepare a message for modifying the samdb
1152         m = ldb.Message()
1153         m.dn = ldb.Dn(samdb, self.dnstr)
1154
1155         m["enabledConnection"] = \
1156             ldb.MessageElement(enablestr, ldb.FLAG_MOD_REPLACE,
1157                                "enabledConnection")
1158         m["fromServer"] = \
1159             ldb.MessageElement(self.from_dnstr, ldb.FLAG_MOD_REPLACE,
1160                                "fromServer")
1161         m["options"] = \
1162             ldb.MessageElement(str(self.options), ldb.FLAG_MOD_REPLACE,
1163                                "options")
1164         m["systemFlags"] = \
1165             ldb.MessageElement(str(self.system_flags), ldb.FLAG_MOD_REPLACE,
1166                                "systemFlags")
1167
1168         if self.transport_dnstr is not None:
1169             m["transportType"] = \
1170                 ldb.MessageElement(str(self.transport_dnstr),
1171                                    ldb.FLAG_MOD_REPLACE, "transportType")
1172         else:
1173             m["transportType"] = \
1174                 ldb.MessageElement([], ldb.FLAG_MOD_DELETE, "transportType")
1175
1176         if self.schedule is not None:
1177             m["schedule"] = \
1178                 ldb.MessageElement(ndr_pack(self.schedule),
1179                                    ldb.FLAG_MOD_REPLACE, "schedule")
1180         else:
1181             m["schedule"] = \
1182                 ldb.MessageElement([], ldb.FLAG_MOD_DELETE, "schedule")
1183         try:
1184             samdb.modify(m)
1185         except ldb.LdbError as e14:
1186             (enum, estr) = e14.args
1187             raise KCCError("Could not modify nTDSConnection for (%s) - (%s)" %
1188                            (self.dnstr, estr))
1189
1190     def set_modified(self, truefalse):
1191         self.to_be_modified = truefalse
1192
1193     def is_schedule_minimum_once_per_week(self):
1194         """Returns True if our schedule includes at least one
1195         replication interval within the week.  False otherwise
1196         """
1197         # replinfo schedule is None means "always", while
1198         # NTDSConnection schedule is None means "never".
1199         if self.schedule is None or self.schedule.dataArray[0] is None:
1200             return False
1201
1202         for slot in self.schedule.dataArray[0].slots:
1203             if (slot & 0x0F) != 0x0:
1204                 return True
1205         return False
1206
1207     def is_equivalent_schedule(self, sched):
1208         """Returns True if our schedule is equivalent to the input
1209         comparison schedule.
1210
1211         :param shed: schedule to compare to
1212         """
1213         # There are 4 cases, where either self.schedule or sched can be None
1214         #
1215         #                   |  self. is None  |   self. is not None
1216         #     --------------+-----------------+--------------------
1217         #     sched is None |     True        |     False
1218         #     --------------+-----------------+--------------------
1219         # sched is not None |    False        |    do calculations
1220
1221         if self.schedule is None:
1222             return sched is None
1223
1224         if sched is None:
1225             return False
1226
1227         if ((self.schedule.size != sched.size or
1228              self.schedule.bandwidth != sched.bandwidth or
1229              self.schedule.numberOfSchedules != sched.numberOfSchedules)):
1230             return False
1231
1232         for i, header in enumerate(self.schedule.headerArray):
1233
1234             if self.schedule.headerArray[i].type != sched.headerArray[i].type:
1235                 return False
1236
1237             if self.schedule.headerArray[i].offset != \
1238                sched.headerArray[i].offset:
1239                 return False
1240
1241             for a, b in zip(self.schedule.dataArray[i].slots,
1242                             sched.dataArray[i].slots):
1243                 if a != b:
1244                     return False
1245         return True
1246
1247     def is_rodc_topology(self):
1248         """Returns True if NTDS Connection specifies RODC
1249         topology only
1250         """
1251         if self.options & dsdb.NTDSCONN_OPT_RODC_TOPOLOGY == 0:
1252             return False
1253         return True
1254
1255     def is_generated(self):
1256         """Returns True if NTDS Connection was generated by the
1257         KCC topology algorithm as opposed to set by the administrator
1258         """
1259         if self.options & dsdb.NTDSCONN_OPT_IS_GENERATED == 0:
1260             return False
1261         return True
1262
1263     def is_override_notify_default(self):
1264         """Returns True if NTDS Connection should override notify default
1265         """
1266         if self.options & dsdb.NTDSCONN_OPT_OVERRIDE_NOTIFY_DEFAULT == 0:
1267             return False
1268         return True
1269
1270     def is_use_notify(self):
1271         """Returns True if NTDS Connection should use notify
1272         """
1273         if self.options & dsdb.NTDSCONN_OPT_USE_NOTIFY == 0:
1274             return False
1275         return True
1276
1277     def is_twoway_sync(self):
1278         """Returns True if NTDS Connection should use twoway sync
1279         """
1280         if self.options & dsdb.NTDSCONN_OPT_TWOWAY_SYNC == 0:
1281             return False
1282         return True
1283
1284     def is_intersite_compression_disabled(self):
1285         """Returns True if NTDS Connection intersite compression
1286         is disabled
1287         """
1288         if self.options & dsdb.NTDSCONN_OPT_DISABLE_INTERSITE_COMPRESSION == 0:
1289             return False
1290         return True
1291
1292     def is_user_owned_schedule(self):
1293         """Returns True if NTDS Connection has a user owned schedule
1294         """
1295         if self.options & dsdb.NTDSCONN_OPT_USER_OWNED_SCHEDULE == 0:
1296             return False
1297         return True
1298
1299     def is_enabled(self):
1300         """Returns True if NTDS Connection is enabled
1301         """
1302         return self.enabled
1303
1304     def get_from_dnstr(self):
1305         '''Return fromServer dn string attribute'''
1306         return self.from_dnstr
1307
1308
1309 class Partition(NamingContext):
1310     """A naming context discovered thru Partitions DN of the config schema.
1311
1312     This is a more specific form of NamingContext class (inheriting from that
1313     class) and it identifies unique attributes enumerated in the Partitions
1314     such as which nTDSDSAs are cross referenced for replicas
1315     """
1316     def __init__(self, partstr):
1317         self.partstr = partstr
1318         self.enabled = True
1319         self.system_flags = 0
1320         self.rw_location_list = []
1321         self.ro_location_list = []
1322
1323         # We don't have enough info to properly
1324         # fill in the naming context yet.  We'll get that
1325         # fully set up with load_partition().
1326         NamingContext.__init__(self, None)
1327
1328     def load_partition(self, samdb):
1329         """Given a Partition class object that has been initialized with its
1330         partition dn string, load the partition from the sam database, identify
1331         the type of the partition (schema, domain, etc) and record the list of
1332         nTDSDSAs that appear in the cross reference attributes
1333         msDS-NC-Replica-Locations and msDS-NC-RO-Replica-Locations.
1334
1335         :param samdb: sam database to load partition from
1336         """
1337         attrs = ["nCName",
1338                  "Enabled",
1339                  "systemFlags",
1340                  "msDS-NC-Replica-Locations",
1341                  "msDS-NC-RO-Replica-Locations"]
1342         try:
1343             res = samdb.search(base=self.partstr, scope=ldb.SCOPE_BASE,
1344                                attrs=attrs)
1345
1346         except ldb.LdbError as e15:
1347             (enum, estr) = e15.args
1348             raise KCCError("Unable to find partition for (%s) - (%s)" %
1349                            (self.partstr, estr))
1350         msg = res[0]
1351         for k in msg.keys():
1352             if k == "dn":
1353                 continue
1354
1355             if k == "Enabled":
1356                 if msg[k][0].upper().lstrip().rstrip() == "TRUE":
1357                     self.enabled = True
1358                 else:
1359                     self.enabled = False
1360                 continue
1361
1362             if k == "systemFlags":
1363                 self.system_flags = int(msg[k][0])
1364                 continue
1365
1366             for value in msg[k]:
1367                 dsdn = dsdb_Dn(samdb, value.decode('utf8'))
1368                 dnstr = str(dsdn.dn)
1369
1370                 if k == "nCName":
1371                     self.nc_dnstr = dnstr
1372                     continue
1373
1374                 if k == "msDS-NC-Replica-Locations":
1375                     self.rw_location_list.append(dnstr)
1376                     continue
1377
1378                 if k == "msDS-NC-RO-Replica-Locations":
1379                     self.ro_location_list.append(dnstr)
1380                     continue
1381
1382         # Now identify what type of NC this partition
1383         # enumerated
1384         self.identify_by_basedn(samdb)
1385
1386     def is_enabled(self):
1387         """Returns True if partition is enabled
1388         """
1389         return self.is_enabled
1390
1391     def is_foreign(self):
1392         """Returns True if this is not an Active Directory NC in our
1393         forest but is instead something else (e.g. a foreign NC)
1394         """
1395         if (self.system_flags & dsdb.SYSTEM_FLAG_CR_NTDS_NC) == 0:
1396             return True
1397         else:
1398             return False
1399
1400     def should_be_present(self, target_dsa):
1401         """Tests whether this partition should have an NC replica
1402         on the target dsa.  This method returns a tuple of
1403         needed=True/False, ro=True/False, partial=True/False
1404
1405         :param target_dsa: should NC be present on target dsa
1406         """
1407         ro = False
1408         partial = False
1409
1410         # If this is the config, schema, or default
1411         # domain NC for the target dsa then it should
1412         # be present
1413         needed = (self.nc_type == NCType.config or
1414                   self.nc_type == NCType.schema or
1415                   (self.nc_type == NCType.domain and
1416                    self.nc_dnstr == target_dsa.default_dnstr))
1417
1418         # A writable replica of an application NC should be present
1419         # if there a cross reference to the target DSA exists.  Depending
1420         # on whether the DSA is ro we examine which type of cross reference
1421         # to look for (msDS-NC-Replica-Locations or
1422         # msDS-NC-RO-Replica-Locations
1423         if self.nc_type == NCType.application:
1424             if target_dsa.is_ro():
1425                 if target_dsa.dsa_dnstr in self.ro_location_list:
1426                     needed = True
1427             else:
1428                 if target_dsa.dsa_dnstr in self.rw_location_list:
1429                     needed = True
1430
1431         # If the target dsa is a gc then a partial replica of a
1432         # domain NC (other than the DSAs default domain) should exist
1433         # if there is also a cross reference for the DSA
1434         if (target_dsa.is_gc() and
1435             self.nc_type == NCType.domain and
1436             self.nc_dnstr != target_dsa.default_dnstr and
1437             (target_dsa.dsa_dnstr in self.ro_location_list or
1438              target_dsa.dsa_dnstr in self.rw_location_list)):
1439             needed = True
1440             partial = True
1441
1442         # partial NCs are always readonly
1443         if needed and (target_dsa.is_ro() or partial):
1444             ro = True
1445
1446         return needed, ro, partial
1447
1448     def __str__(self):
1449         '''Debug dump string output of class'''
1450         text = "%s" % NamingContext.__str__(self)
1451         text = text + "\n\tpartdn=%s" % self.partstr
1452         for k in self.rw_location_list:
1453             text = text + "\n\tmsDS-NC-Replica-Locations=%s" % k
1454         for k in self.ro_location_list:
1455             text = text + "\n\tmsDS-NC-RO-Replica-Locations=%s" % k
1456         return text
1457
1458
1459 class Site(object):
1460     """An individual site object discovered thru the configuration
1461     naming context.  Contains all DSAs that exist within the site
1462     """
1463     def __init__(self, site_dnstr, nt_now):
1464         self.site_dnstr = site_dnstr
1465         self.site_guid = None
1466         self.site_options = 0
1467         self.site_topo_generator = None
1468         self.site_topo_failover = 0  # appears to be in minutes
1469         self.dsa_table = {}
1470         self.rw_dsa_table = {}
1471         self.nt_now = nt_now
1472
1473     def load_site(self, samdb):
1474         """Loads the NTDS Site Settings options attribute for the site
1475         as well as querying and loading all DSAs that appear within
1476         the site.
1477         """
1478         ssdn = "CN=NTDS Site Settings,%s" % self.site_dnstr
1479         attrs = ["options",
1480                  "interSiteTopologyFailover",
1481                  "interSiteTopologyGenerator"]
1482         try:
1483             res = samdb.search(base=ssdn, scope=ldb.SCOPE_BASE,
1484                                attrs=attrs)
1485             self_res = samdb.search(base=self.site_dnstr, scope=ldb.SCOPE_BASE,
1486                                     attrs=['objectGUID'])
1487         except ldb.LdbError as e16:
1488             (enum, estr) = e16.args
1489             raise KCCError("Unable to find site settings for (%s) - (%s)" %
1490                            (ssdn, estr))
1491
1492         msg = res[0]
1493         if "options" in msg:
1494             self.site_options = int(msg["options"][0])
1495
1496         if "interSiteTopologyGenerator" in msg:
1497             self.site_topo_generator = \
1498                 str(msg["interSiteTopologyGenerator"][0])
1499
1500         if "interSiteTopologyFailover" in msg:
1501             self.site_topo_failover = int(msg["interSiteTopologyFailover"][0])
1502
1503         msg = self_res[0]
1504         if "objectGUID" in msg:
1505             self.site_guid = misc.GUID(samdb.schema_format_value("objectGUID",
1506                                        msg["objectGUID"][0]))
1507
1508         self.load_all_dsa(samdb)
1509
1510     def load_all_dsa(self, samdb):
1511         """Discover all nTDSDSA thru the sites entry and
1512         instantiate and load the DSAs.  Each dsa is inserted
1513         into the dsa_table by dn string.
1514         """
1515         try:
1516             res = samdb.search(self.site_dnstr,
1517                                scope=ldb.SCOPE_SUBTREE,
1518                                expression="(objectClass=nTDSDSA)")
1519         except ldb.LdbError as e17:
1520             (enum, estr) = e17.args
1521             raise KCCError("Unable to find nTDSDSAs - (%s)" % estr)
1522
1523         for msg in res:
1524             dnstr = str(msg.dn)
1525
1526             # already loaded
1527             if dnstr in self.dsa_table:
1528                 continue
1529
1530             dsa = DirectoryServiceAgent(dnstr)
1531
1532             dsa.load_dsa(samdb)
1533
1534             # Assign this dsa to my dsa table
1535             # and index by dsa dn
1536             self.dsa_table[dnstr] = dsa
1537             if not dsa.is_ro():
1538                 self.rw_dsa_table[dnstr] = dsa
1539
1540     def get_dsa(self, dnstr):
1541         """Return a previously loaded DSA object by consulting
1542         the sites dsa_table for the provided DSA dn string
1543
1544         :return: None if DSA doesn't exist
1545         """
1546         return self.dsa_table.get(dnstr)
1547
1548     def select_istg(self, samdb, mydsa, ro):
1549         """Determine if my DC should be an intersite topology
1550         generator.  If my DC is the istg and is both a writeable
1551         DC and the database is opened in write mode then we perform
1552         an originating update to set the interSiteTopologyGenerator
1553         attribute in the NTDS Site Settings object.  An RODC always
1554         acts as an ISTG for itself.
1555         """
1556         # The KCC on an RODC always acts as an ISTG for itself
1557         if mydsa.dsa_is_ro:
1558             mydsa.dsa_is_istg = True
1559             self.site_topo_generator = mydsa.dsa_dnstr
1560             return True
1561
1562         c_rep = get_dsa_config_rep(mydsa)
1563
1564         # Load repsFrom and replUpToDateVector if not already loaded
1565         # so we can get the current state of the config replica and
1566         # whether we are getting updates from the istg
1567         c_rep.load_repsFrom(samdb)
1568
1569         c_rep.load_replUpToDateVector(samdb)
1570
1571         # From MS-ADTS 6.2.2.3.1 ISTG selection:
1572         #     First, the KCC on a writable DC determines whether it acts
1573         #     as an ISTG for its site
1574         #
1575         #     Let s be the object such that s!lDAPDisplayName = nTDSDSA
1576         #     and classSchema in s!objectClass.
1577         #
1578         #     Let D be the sequence of objects o in the site of the local
1579         #     DC such that o!objectCategory = s. D is sorted in ascending
1580         #     order by objectGUID.
1581         #
1582         # Which is a fancy way of saying "sort all the nTDSDSA objects
1583         # in the site by guid in ascending order".   Place sorted list
1584         # in D_sort[]
1585         D_sort = sorted(
1586             self.rw_dsa_table.values(),
1587             key=lambda dsa: ndr_pack(dsa.dsa_guid))
1588
1589         # double word number of 100 nanosecond intervals since 1600s
1590
1591         # Let f be the duration o!interSiteTopologyFailover seconds, or 2 hours
1592         # if o!interSiteTopologyFailover is 0 or has no value.
1593         #
1594         # Note: lastSuccess and ntnow are in 100 nanosecond intervals
1595         #       so it appears we have to turn f into the same interval
1596         #
1597         #       interSiteTopologyFailover (if set) appears to be in minutes
1598         #       so we'll need to convert to senconds and then 100 nanosecond
1599         #       intervals
1600         #       XXX [MS-ADTS] 6.2.2.3.1 says it is seconds, not minutes.
1601         #
1602         #       10,000,000 is number of 100 nanosecond intervals in a second
1603         if self.site_topo_failover == 0:
1604             f = 2 * 60 * 60 * 10000000
1605         else:
1606             f = self.site_topo_failover * 60 * 10000000
1607
1608         # Let o be the site settings object for the site of the local
1609         # DC, or NULL if no such o exists.
1610         d_dsa = self.dsa_table.get(self.site_topo_generator)
1611
1612         # From MS-ADTS 6.2.2.3.1 ISTG selection:
1613         #     If o != NULL and o!interSiteTopologyGenerator is not the
1614         #     nTDSDSA object for the local DC and
1615         #     o!interSiteTopologyGenerator is an element dj of sequence D:
1616         #
1617         if d_dsa is not None and d_dsa is not mydsa:
1618             # From MS-ADTS 6.2.2.3.1 ISTG Selection:
1619             #     Let c be the cursor in the replUpToDateVector variable
1620             #     associated with the NC replica of the config NC such
1621             #     that c.uuidDsa = dj!invocationId. If no such c exists
1622             #     (No evidence of replication from current ITSG):
1623             #         Let i = j.
1624             #         Let t = 0.
1625             #
1626             #     Else if the current time < c.timeLastSyncSuccess - f
1627             #     (Evidence of time sync problem on current ISTG):
1628             #         Let i = 0.
1629             #         Let t = 0.
1630             #
1631             #     Else (Evidence of replication from current ITSG):
1632             #         Let i = j.
1633             #         Let t = c.timeLastSyncSuccess.
1634             #
1635             # last_success appears to be a double word containing
1636             #     number of 100 nanosecond intervals since the 1600s
1637             j_idx = D_sort.index(d_dsa)
1638
1639             found = False
1640             for cursor in c_rep.rep_replUpToDateVector_cursors:
1641                 if d_dsa.dsa_ivid == cursor.source_dsa_invocation_id:
1642                     found = True
1643                     break
1644
1645             if not found:
1646                 i_idx = j_idx
1647                 t_time = 0
1648
1649             # XXX doc says current time < c.timeLastSyncSuccess - f
1650             # which is true only if f is negative or clocks are wrong.
1651             # f is not negative in the default case (2 hours).
1652             elif self.nt_now - cursor.last_sync_success > f:
1653                 i_idx = 0
1654                 t_time = 0
1655             else:
1656                 i_idx = j_idx
1657                 t_time = cursor.last_sync_success
1658
1659         # Otherwise (Nominate local DC as ISTG):
1660         #     Let i be the integer such that di is the nTDSDSA
1661         #         object for the local DC.
1662         #     Let t = the current time.
1663         else:
1664             i_idx = D_sort.index(mydsa)
1665             t_time = self.nt_now
1666
1667         # Compute a function that maintains the current ISTG if
1668         # it is alive, cycles through other candidates if not.
1669         #
1670         # Let k be the integer (i + ((current time - t) /
1671         #     o!interSiteTopologyFailover)) MOD |D|.
1672         #
1673         # Note: We don't want to divide by zero here so they must
1674         #       have meant "f" instead of "o!interSiteTopologyFailover"
1675         k_idx = (i_idx + ((self.nt_now - t_time) // f)) % len(D_sort)
1676
1677         # The local writable DC acts as an ISTG for its site if and
1678         # only if dk is the nTDSDSA object for the local DC. If the
1679         # local DC does not act as an ISTG, the KCC skips the
1680         # remainder of this task.
1681         d_dsa = D_sort[k_idx]
1682         d_dsa.dsa_is_istg = True
1683
1684         # Update if we are the ISTG, otherwise return
1685         if d_dsa is not mydsa:
1686             return False
1687
1688         # Nothing to do
1689         if self.site_topo_generator == mydsa.dsa_dnstr:
1690             return True
1691
1692         self.site_topo_generator = mydsa.dsa_dnstr
1693
1694         # If readonly database then do not perform a
1695         # persistent update
1696         if ro:
1697             return True
1698
1699         # Perform update to the samdb
1700         ssdn = "CN=NTDS Site Settings,%s" % self.site_dnstr
1701
1702         m = ldb.Message()
1703         m.dn = ldb.Dn(samdb, ssdn)
1704
1705         m["interSiteTopologyGenerator"] = \
1706             ldb.MessageElement(mydsa.dsa_dnstr, ldb.FLAG_MOD_REPLACE,
1707                                "interSiteTopologyGenerator")
1708         try:
1709             samdb.modify(m)
1710
1711         except ldb.LdbError as estr:
1712             raise KCCError(
1713                 "Could not set interSiteTopologyGenerator for (%s) - (%s)" %
1714                 (ssdn, estr))
1715         return True
1716
1717     def is_intrasite_topology_disabled(self):
1718         '''Returns True if intra-site topology is disabled for site'''
1719         return (self.site_options &
1720                 dsdb.DS_NTDSSETTINGS_OPT_IS_AUTO_TOPOLOGY_DISABLED) != 0
1721
1722     def is_intersite_topology_disabled(self):
1723         '''Returns True if inter-site topology is disabled for site'''
1724         return ((self.site_options &
1725                  dsdb.DS_NTDSSETTINGS_OPT_IS_INTER_SITE_AUTO_TOPOLOGY_DISABLED)
1726                 != 0)
1727
1728     def is_random_bridgehead_disabled(self):
1729         '''Returns True if selection of random bridgehead is disabled'''
1730         return (self.site_options &
1731                 dsdb.DS_NTDSSETTINGS_OPT_IS_RAND_BH_SELECTION_DISABLED) != 0
1732
1733     def is_detect_stale_disabled(self):
1734         '''Returns True if detect stale is disabled for site'''
1735         return (self.site_options &
1736                 dsdb.DS_NTDSSETTINGS_OPT_IS_TOPL_DETECT_STALE_DISABLED) != 0
1737
1738     def is_cleanup_ntdsconn_disabled(self):
1739         '''Returns True if NTDS Connection cleanup is disabled for site'''
1740         return (self.site_options &
1741                 dsdb.DS_NTDSSETTINGS_OPT_IS_TOPL_CLEANUP_DISABLED) != 0
1742
1743     def same_site(self, dsa):
1744         '''Return True if dsa is in this site'''
1745         if self.get_dsa(dsa.dsa_dnstr):
1746             return True
1747         return False
1748
1749     def is_rodc_site(self):
1750         if len(self.dsa_table) > 0 and len(self.rw_dsa_table) == 0:
1751             return True
1752         return False
1753
1754     def __str__(self):
1755         '''Debug dump string output of class'''
1756         text = "%s:" % self.__class__.__name__
1757         text = text + "\n\tdn=%s" % self.site_dnstr
1758         text = text + "\n\toptions=0x%X" % self.site_options
1759         text = text + "\n\ttopo_generator=%s" % self.site_topo_generator
1760         text = text + "\n\ttopo_failover=%d" % self.site_topo_failover
1761         for key, dsa in self.dsa_table.items():
1762             text = text + "\n%s" % dsa
1763         return text
1764
1765
1766 class GraphNode(object):
1767     """A graph node describing a set of edges that should be directed to it.
1768
1769     Each edge is a connection for a particular naming context replica directed
1770     from another node in the forest to this node.
1771     """
1772
1773     def __init__(self, dsa_dnstr, max_node_edges):
1774         """Instantiate the graph node according to a DSA dn string
1775
1776         :param max_node_edges: maximum number of edges that should ever
1777             be directed to the node
1778         """
1779         self.max_edges = max_node_edges
1780         self.dsa_dnstr = dsa_dnstr
1781         self.edge_from = []
1782
1783     def __str__(self):
1784         text = "%s:" % self.__class__.__name__
1785         text = text + "\n\tdsa_dnstr=%s" % self.dsa_dnstr
1786         text = text + "\n\tmax_edges=%d" % self.max_edges
1787
1788         for i, edge in enumerate(self.edge_from):
1789             if isinstance(edge, str):
1790                 text += "\n\tedge_from[%d]=%s" % (i, edge)
1791
1792         return text
1793
1794     def add_edge_from(self, from_dsa_dnstr):
1795         """Add an edge from the dsa to our graph nodes edge from list
1796
1797         :param from_dsa_dnstr: the dsa that the edge emanates from
1798         """
1799         assert isinstance(from_dsa_dnstr, str)
1800
1801         # No edges from myself to myself
1802         if from_dsa_dnstr == self.dsa_dnstr:
1803             return False
1804         # Only one edge from a particular node
1805         if from_dsa_dnstr in self.edge_from:
1806             return False
1807         # Not too many edges
1808         if len(self.edge_from) >= self.max_edges:
1809             return False
1810         self.edge_from.append(from_dsa_dnstr)
1811         return True
1812
1813     def add_edges_from_connections(self, dsa):
1814         """For each nTDSConnection object associated with a particular
1815         DSA, we test if it implies an edge to this graph node (i.e.
1816         the "fromServer" attribute).  If it does then we add an
1817         edge from the server unless we are over the max edges for this
1818         graph node
1819
1820         :param dsa: dsa with a dnstr equivalent to his graph node
1821         """
1822         for connect in dsa.connect_table.values():
1823             self.add_edge_from(connect.from_dnstr)
1824
1825     def add_connections_from_edges(self, dsa, transport):
1826         """For each edge directed to this graph node, ensure there
1827            is a corresponding nTDSConnection object in the dsa.
1828         """
1829         for edge_dnstr in self.edge_from:
1830             connections = dsa.get_connection_by_from_dnstr(edge_dnstr)
1831
1832             # For each edge directed to the NC replica that
1833             # "should be present" on the local DC, the KCC determines
1834             # whether an object c exists such that:
1835             #
1836             #    c is a child of the DC's nTDSDSA object.
1837             #    c.objectCategory = nTDSConnection
1838             #
1839             # Given the NC replica ri from which the edge is directed,
1840             #    c.fromServer is the dsname of the nTDSDSA object of
1841             #    the DC on which ri "is present".
1842             #
1843             #    c.options does not contain NTDSCONN_OPT_RODC_TOPOLOGY
1844
1845             found_valid = False
1846             for connect in connections:
1847                 if connect.is_rodc_topology():
1848                     continue
1849                 found_valid = True
1850
1851             if found_valid:
1852                 continue
1853
1854             # if no such object exists then the KCC adds an object
1855             # c with the following attributes
1856
1857             # Generate a new dnstr for this nTDSConnection
1858             opt = dsdb.NTDSCONN_OPT_IS_GENERATED
1859             flags = (dsdb.SYSTEM_FLAG_CONFIG_ALLOW_RENAME |
1860                      dsdb.SYSTEM_FLAG_CONFIG_ALLOW_MOVE)
1861
1862             dsa.new_connection(opt, flags, transport, edge_dnstr, None)
1863
1864     def has_sufficient_edges(self):
1865         '''Return True if we have met the maximum "from edges" criteria'''
1866         if len(self.edge_from) >= self.max_edges:
1867             return True
1868         return False
1869
1870
1871 class Transport(object):
1872     """Class defines a Inter-site transport found under Sites
1873     """
1874
1875     def __init__(self, dnstr):
1876         self.dnstr = dnstr
1877         self.options = 0
1878         self.guid = None
1879         self.name = None
1880         self.address_attr = None
1881         self.bridgehead_list = []
1882
1883     def __str__(self):
1884         '''Debug dump string output of Transport object'''
1885
1886         text = "%s:\n\tdn=%s" % (self.__class__.__name__, self.dnstr)
1887         text = text + "\n\tguid=%s" % str(self.guid)
1888         text = text + "\n\toptions=%d" % self.options
1889         text = text + "\n\taddress_attr=%s" % self.address_attr
1890         text = text + "\n\tname=%s" % self.name
1891         for dnstr in self.bridgehead_list:
1892             text = text + "\n\tbridgehead_list=%s" % dnstr
1893
1894         return text
1895
1896     def load_transport(self, samdb):
1897         """Given a Transport object with an prior initialization
1898         for the object's DN, search for the DN and load attributes
1899         from the samdb.
1900         """
1901         attrs = ["objectGUID",
1902                  "options",
1903                  "name",
1904                  "bridgeheadServerListBL",
1905                  "transportAddressAttribute"]
1906         try:
1907             res = samdb.search(base=self.dnstr, scope=ldb.SCOPE_BASE,
1908                                attrs=attrs)
1909
1910         except ldb.LdbError as e18:
1911             (enum, estr) = e18.args
1912             raise KCCError("Unable to find Transport for (%s) - (%s)" %
1913                            (self.dnstr, estr))
1914
1915         msg = res[0]
1916         self.guid = misc.GUID(samdb.schema_format_value("objectGUID",
1917                               msg["objectGUID"][0]))
1918
1919         if "options" in msg:
1920             self.options = int(msg["options"][0])
1921
1922         if "transportAddressAttribute" in msg:
1923             self.address_attr = str(msg["transportAddressAttribute"][0])
1924
1925         if "name" in msg:
1926             self.name = str(msg["name"][0])
1927
1928         if "bridgeheadServerListBL" in msg:
1929             for value in msg["bridgeheadServerListBL"]:
1930                 dsdn = dsdb_Dn(samdb, value.decode('utf8'))
1931                 dnstr = str(dsdn.dn)
1932                 if dnstr not in self.bridgehead_list:
1933                     self.bridgehead_list.append(dnstr)
1934
1935
1936 class RepsFromTo(object):
1937     """Class encapsulation of the NDR repsFromToBlob.
1938
1939     Removes the necessity of external code having to
1940     understand about other_info or manipulation of
1941     update flags.
1942     """
1943     def __init__(self, nc_dnstr=None, ndr_blob=None):
1944
1945         self.__dict__['to_be_deleted'] = False
1946         self.__dict__['nc_dnstr'] = nc_dnstr
1947         self.__dict__['update_flags'] = 0x0
1948         # XXX the following sounds dubious and/or better solved
1949         # elsewhere, but lets leave it for now. In particular, there
1950         # seems to be no reason for all the non-ndr generated
1951         # attributes to be handled in the round about way (e.g.
1952         # self.__dict__['to_be_deleted'] = False above). On the other
1953         # hand, it all seems to work. Hooray! Hands off!.
1954         #
1955         # WARNING:
1956         #
1957         # There is a very subtle bug here with python
1958         # and our NDR code.  If you assign directly to
1959         # a NDR produced struct (e.g. t_repsFrom.ctr.other_info)
1960         # then a proper python GC reference count is not
1961         # maintained.
1962         #
1963         # To work around this we maintain an internal
1964         # reference to "dns_name(x)" and "other_info" elements
1965         # of repsFromToBlob.  This internal reference
1966         # is hidden within this class but it is why you
1967         # see statements like this below:
1968         #
1969         #   self.__dict__['ndr_blob'].ctr.other_info = \
1970         #        self.__dict__['other_info'] = drsblobs.repsFromTo1OtherInfo()
1971         #
1972         # That would appear to be a redundant assignment but
1973         # it is necessary to hold a proper python GC reference
1974         # count.
1975         if ndr_blob is None:
1976             self.__dict__['ndr_blob'] = drsblobs.repsFromToBlob()
1977             self.__dict__['ndr_blob'].version = 0x1
1978             self.__dict__['dns_name1'] = None
1979             self.__dict__['dns_name2'] = None
1980
1981             self.__dict__['ndr_blob'].ctr.other_info = \
1982                 self.__dict__['other_info'] = drsblobs.repsFromTo1OtherInfo()
1983
1984         else:
1985             self.__dict__['ndr_blob'] = ndr_blob
1986             self.__dict__['other_info'] = ndr_blob.ctr.other_info
1987
1988             if ndr_blob.version == 0x1:
1989                 self.__dict__['dns_name1'] = ndr_blob.ctr.other_info.dns_name
1990                 self.__dict__['dns_name2'] = None
1991             else:
1992                 self.__dict__['dns_name1'] = ndr_blob.ctr.other_info.dns_name1
1993                 self.__dict__['dns_name2'] = ndr_blob.ctr.other_info.dns_name2
1994
1995     def __str__(self):
1996         '''Debug dump string output of class'''
1997
1998         text = "%s:" % self.__class__.__name__
1999         text += "\n\tdnstr=%s" % self.nc_dnstr
2000         text += "\n\tupdate_flags=0x%X" % self.update_flags
2001         text += "\n\tversion=%d" % self.version
2002         text += "\n\tsource_dsa_obj_guid=%s" % self.source_dsa_obj_guid
2003         text += ("\n\tsource_dsa_invocation_id=%s" %
2004                  self.source_dsa_invocation_id)
2005         text += "\n\ttransport_guid=%s" % self.transport_guid
2006         text += "\n\treplica_flags=0x%X" % self.replica_flags
2007         text += ("\n\tconsecutive_sync_failures=%d" %
2008                  self.consecutive_sync_failures)
2009         text += "\n\tlast_success=%s" % self.last_success
2010         text += "\n\tlast_attempt=%s" % self.last_attempt
2011         text += "\n\tdns_name1=%s" % self.dns_name1
2012         text += "\n\tdns_name2=%s" % self.dns_name2
2013         text += "\n\tschedule[ "
2014         for slot in self.schedule:
2015             text += "0x%X " % slot
2016         text += "]"
2017
2018         return text
2019
2020     def __setattr__(self, item, value):
2021         """Set an attribute and chyange update flag.
2022
2023         Be aware that setting any RepsFromTo attribute will set the
2024         drsuapi.DRSUAPI_DRS_UPDATE_ADDRESS update flag.
2025         """
2026         if item in ['schedule', 'replica_flags', 'transport_guid',
2027                     'source_dsa_obj_guid', 'source_dsa_invocation_id',
2028                     'consecutive_sync_failures', 'last_success',
2029                     'last_attempt']:
2030
2031             if item in ['replica_flags']:
2032                 self.__dict__['update_flags'] |= drsuapi.DRSUAPI_DRS_UPDATE_FLAGS
2033             elif item in ['schedule']:
2034                 self.__dict__['update_flags'] |= drsuapi.DRSUAPI_DRS_UPDATE_SCHEDULE
2035
2036             setattr(self.__dict__['ndr_blob'].ctr, item, value)
2037
2038         elif item in ['dns_name1']:
2039             self.__dict__['dns_name1'] = value
2040
2041             if self.__dict__['ndr_blob'].version == 0x1:
2042                 self.__dict__['ndr_blob'].ctr.other_info.dns_name = \
2043                     self.__dict__['dns_name1']
2044             else:
2045                 self.__dict__['ndr_blob'].ctr.other_info.dns_name1 = \
2046                     self.__dict__['dns_name1']
2047
2048         elif item in ['dns_name2']:
2049             self.__dict__['dns_name2'] = value
2050
2051             if self.__dict__['ndr_blob'].version == 0x1:
2052                 raise AttributeError(item)
2053             else:
2054                 self.__dict__['ndr_blob'].ctr.other_info.dns_name2 = \
2055                     self.__dict__['dns_name2']
2056
2057         elif item in ['nc_dnstr']:
2058             self.__dict__['nc_dnstr'] = value
2059
2060         elif item in ['to_be_deleted']:
2061             self.__dict__['to_be_deleted'] = value
2062
2063         elif item in ['version']:
2064             raise AttributeError("Attempt to set readonly attribute %s" % item)
2065         else:
2066             raise AttributeError("Unknown attribute %s" % item)
2067
2068         self.__dict__['update_flags'] |= drsuapi.DRSUAPI_DRS_UPDATE_ADDRESS
2069
2070     def __getattr__(self, item):
2071         """Overload of RepsFromTo attribute retrieval.
2072
2073         Allows external code to ignore substructures within the blob
2074         """
2075         if item in ['schedule', 'replica_flags', 'transport_guid',
2076                     'source_dsa_obj_guid', 'source_dsa_invocation_id',
2077                     'consecutive_sync_failures', 'last_success',
2078                     'last_attempt']:
2079             return getattr(self.__dict__['ndr_blob'].ctr, item)
2080
2081         elif item in ['version']:
2082             return self.__dict__['ndr_blob'].version
2083
2084         elif item in ['dns_name1']:
2085             if self.__dict__['ndr_blob'].version == 0x1:
2086                 return self.__dict__['ndr_blob'].ctr.other_info.dns_name
2087             else:
2088                 return self.__dict__['ndr_blob'].ctr.other_info.dns_name1
2089
2090         elif item in ['dns_name2']:
2091             if self.__dict__['ndr_blob'].version == 0x1:
2092                 raise AttributeError(item)
2093             else:
2094                 return self.__dict__['ndr_blob'].ctr.other_info.dns_name2
2095
2096         elif item in ['to_be_deleted']:
2097             return self.__dict__['to_be_deleted']
2098
2099         elif item in ['nc_dnstr']:
2100             return self.__dict__['nc_dnstr']
2101
2102         elif item in ['update_flags']:
2103             return self.__dict__['update_flags']
2104
2105         raise AttributeError("Unknown attribute %s" % item)
2106
2107     def is_modified(self):
2108         return (self.update_flags != 0x0)
2109
2110     def set_unmodified(self):
2111         self.__dict__['update_flags'] = 0x0
2112
2113
2114 class SiteLink(object):
2115     """Class defines a site link found under sites
2116     """
2117
2118     def __init__(self, dnstr):
2119         self.dnstr = dnstr
2120         self.options = 0
2121         self.system_flags = 0
2122         self.cost = 0
2123         self.schedule = None
2124         self.interval = None
2125         self.site_list = []
2126
2127     def __str__(self):
2128         '''Debug dump string output of Transport object'''
2129
2130         text = "%s:\n\tdn=%s" % (self.__class__.__name__, self.dnstr)
2131         text = text + "\n\toptions=%d" % self.options
2132         text = text + "\n\tsystem_flags=%d" % self.system_flags
2133         text = text + "\n\tcost=%d" % self.cost
2134         text = text + "\n\tinterval=%s" % self.interval
2135
2136         if self.schedule is not None:
2137             text += "\n\tschedule.size=%s" % self.schedule.size
2138             text += "\n\tschedule.bandwidth=%s" % self.schedule.bandwidth
2139             text += ("\n\tschedule.numberOfSchedules=%s" %
2140                      self.schedule.numberOfSchedules)
2141
2142             for i, header in enumerate(self.schedule.headerArray):
2143                 text += ("\n\tschedule.headerArray[%d].type=%d" %
2144                          (i, header.type))
2145                 text += ("\n\tschedule.headerArray[%d].offset=%d" %
2146                          (i, header.offset))
2147                 text = text + "\n\tschedule.dataArray[%d].slots[ " % i
2148                 for slot in self.schedule.dataArray[i].slots:
2149                     text = text + "0x%X " % slot
2150                 text = text + "]"
2151
2152         for guid, dn in self.site_list:
2153             text = text + "\n\tsite_list=%s (%s)" % (guid, dn)
2154         return text
2155
2156     def load_sitelink(self, samdb):
2157         """Given a siteLink object with an prior initialization
2158         for the object's DN, search for the DN and load attributes
2159         from the samdb.
2160         """
2161         attrs = ["options",
2162                  "systemFlags",
2163                  "cost",
2164                  "schedule",
2165                  "replInterval",
2166                  "siteList"]
2167         try:
2168             res = samdb.search(base=self.dnstr, scope=ldb.SCOPE_BASE,
2169                                attrs=attrs, controls=['extended_dn:0'])
2170
2171         except ldb.LdbError as e19:
2172             (enum, estr) = e19.args
2173             raise KCCError("Unable to find SiteLink for (%s) - (%s)" %
2174                            (self.dnstr, estr))
2175
2176         msg = res[0]
2177
2178         if "options" in msg:
2179             self.options = int(msg["options"][0])
2180
2181         if "systemFlags" in msg:
2182             self.system_flags = int(msg["systemFlags"][0])
2183
2184         if "cost" in msg:
2185             self.cost = int(msg["cost"][0])
2186
2187         if "replInterval" in msg:
2188             self.interval = int(msg["replInterval"][0])
2189
2190         if "siteList" in msg:
2191             for value in msg["siteList"]:
2192                 dsdn = dsdb_Dn(samdb, value.decode('utf8'))
2193                 guid = misc.GUID(dsdn.dn.get_extended_component('GUID'))
2194                 dnstr = str(dsdn.dn)
2195                 if (guid, dnstr) not in self.site_list:
2196                     self.site_list.append((guid, dnstr))
2197
2198         if "schedule" in msg:
2199             self.schedule = ndr_unpack(drsblobs.schedule, value)
2200         else:
2201             self.schedule = new_connection_schedule()
2202
2203
2204 class KCCFailedObject(object):
2205     def __init__(self, uuid, failure_count, time_first_failure,
2206                  last_result, dns_name):
2207         self.uuid = uuid
2208         self.failure_count = failure_count
2209         self.time_first_failure = time_first_failure
2210         self.last_result = last_result
2211         self.dns_name = dns_name
2212
2213
2214 ##################################################
2215 # Global Functions and Variables
2216 ##################################################
2217
2218 def get_dsa_config_rep(dsa):
2219     # Find configuration NC replica for the DSA
2220     for c_rep in dsa.current_rep_table.values():
2221         if c_rep.is_config():
2222             return c_rep
2223
2224     raise KCCError("Unable to find config NC replica for (%s)" %
2225                    dsa.dsa_dnstr)
2226
2227
2228 def new_connection_schedule():
2229     """Create a default schedule for an NTDSConnection or Sitelink. This
2230     is packed differently from the repltimes schedule used elsewhere
2231     in KCC (where the 168 nibbles are packed into 84 bytes).
2232     """
2233     # 168 byte instances of the 0x01 value.  The low order 4 bits
2234     # of the byte equate to 15 minute intervals within a single hour.
2235     # There are 168 bytes because there are 168 hours in a full week
2236     # Effectively we are saying to perform replication at the end of
2237     # each hour of the week
2238     schedule = drsblobs.schedule()
2239
2240     schedule.size = 188
2241     schedule.bandwidth = 0
2242     schedule.numberOfSchedules = 1
2243
2244     header = drsblobs.scheduleHeader()
2245     header.type = 0
2246     header.offset = 20
2247
2248     schedule.headerArray = [header]
2249
2250     data = drsblobs.scheduleSlots()
2251     data.slots = [0x01] * 168
2252
2253     schedule.dataArray = [data]
2254     return schedule
2255
2256
2257 ##################################################
2258 # DNS related calls
2259 ##################################################
2260
2261 def uncovered_sites_to_cover(samdb, site_name):
2262     """
2263     Discover which sites have no DCs and whose lowest single-hop cost
2264     distance for any link attached to that site is linked to the site supplied.
2265
2266     We compare the lowest cost of your single-hop link to this site to all of
2267     those available (if it exists). This means that a lower ranked siteLink
2268     with only the uncovered site can trump any available links (but this can
2269     only be done with specific, poorly enacted user configuration).
2270
2271     If the site is connected to more than one other site with the same
2272     siteLink, only the largest site (failing that sorted alphabetically)
2273     creates the DNS records.
2274
2275     :param samdb database
2276     :param site_name origin site (with a DC)
2277
2278     :return a list of sites this site should be covering (for DNS)
2279     """
2280     sites_to_cover = []
2281
2282     server_res = samdb.search(base=samdb.get_config_basedn(),
2283                               scope=ldb.SCOPE_SUBTREE,
2284                               expression="(&(objectClass=server)"
2285                               "(serverReference=*))")
2286
2287     site_res = samdb.search(base=samdb.get_config_basedn(),
2288                             scope=ldb.SCOPE_SUBTREE,
2289                             expression="(objectClass=site)")
2290
2291     sites_in_use = Counter()
2292     dc_count = 0
2293
2294     # Assume server is of form DC,Servers,Site-ABCD because of schema
2295     for msg in server_res:
2296         site_dn = msg.dn.parent().parent()
2297         sites_in_use[site_dn.canonical_str()] += 1
2298
2299         if site_dn.get_rdn_value().lower() == site_name.lower():
2300             dc_count += 1
2301
2302     if len(sites_in_use) != len(site_res):
2303         # There is a possible uncovered site
2304         sites_uncovered = []
2305
2306         for msg in site_res:
2307             if msg.dn.canonical_str() not in sites_in_use:
2308                 sites_uncovered.append(msg)
2309
2310         own_site_dn = "CN={},CN=Sites,{}".format(
2311             ldb.binary_encode(site_name),
2312             ldb.binary_encode(str(samdb.get_config_basedn()))
2313         )
2314
2315         for site in sites_uncovered:
2316             encoded_dn = ldb.binary_encode(str(site.dn))
2317
2318             # Get a sorted list of all siteLinks featuring the uncovered site
2319             link_res1 = samdb.search(base=samdb.get_config_basedn(),
2320                                      scope=ldb.SCOPE_SUBTREE, attrs=["cost"],
2321                                      expression="(&(objectClass=siteLink)"
2322                                      "(siteList={}))".format(encoded_dn),
2323                                      controls=["server_sort:1:0:cost"])
2324
2325             # Get a sorted list of all siteLinks connecting this an the
2326             # uncovered site
2327             link_res2 = samdb.search(base=samdb.get_config_basedn(),
2328                                      scope=ldb.SCOPE_SUBTREE,
2329                                      attrs=["cost", "siteList"],
2330                                      expression="(&(objectClass=siteLink)"
2331                                      "(siteList={})(siteList={}))".format(
2332                                          own_site_dn,
2333                                          encoded_dn),
2334                                      controls=["server_sort:1:0:cost"])
2335
2336             # Add to list if your link is equal in cost to lowest cost link
2337             if len(link_res1) > 0 and len(link_res2) > 0:
2338                 cost1 = int(link_res1[0]['cost'][0])
2339                 cost2 = int(link_res2[0]['cost'][0])
2340
2341                 # Own siteLink must match the lowest cost link
2342                 if cost1 != cost2:
2343                     continue
2344
2345                 # In a siteLink with more than 2 sites attached, only pick the
2346                 # largest site, and if there are multiple, the earliest
2347                 # alphabetically.
2348                 to_cover = True
2349                 for site_val in link_res2[0]['siteList']:
2350                     site_dn = ldb.Dn(samdb, str(site_val))
2351                     site_dn_str = site_dn.canonical_str()
2352                     site_rdn = site_dn.get_rdn_value().lower()
2353                     if sites_in_use[site_dn_str] > dc_count:
2354                         to_cover = False
2355                         break
2356                     elif (sites_in_use[site_dn_str] == dc_count and
2357                           site_rdn < site_name.lower()):
2358                         to_cover = False
2359                         break
2360
2361                 if to_cover:
2362                     site_cover_rdn = site.dn.get_rdn_value()
2363                     sites_to_cover.append(site_cover_rdn.lower())
2364
2365     return sites_to_cover