/// <summary>
/// Initializes a new instance of the <see cref="ColumnAccessor" /> class.
/// </summary>
/// <param name="cursor">The cursor.</param>
/// <param name="isamSession">The session.</param>
/// <param name="tableid">The tableid.</param>
/// <param name="grbit">The grbit.</param>
internal ColumnAccessor(Cursor cursor, IsamSession isamSession, JET_TABLEID tableid, RetrieveColumnGrbit grbit)
{
this.cursor = cursor;
this.isamSession = isamSession;
this.tableid = tableid;
this.grbit = grbit;
}
protected virtual void Dispose(bool disposing)
{
if (disposing && this.cursor != null)
{
this.cursor.Dispose();
this.cursor = null;
}
}
public LinkResolver(IsamDatabase database, DirectorySchema schema)
{
this.schema = schema;
this.cursor = database.OpenCursor(ADConstants.LinkTableName);
if (this.cursor.TableDefinition.Indices.Contains(linkIndex2008))
{
this.cursor.SetCurrentIndex(linkIndex2008);
}
else
{
// Fallback to the old index if the newer one does not exist
cursor.SetCurrentIndex(linkIndex2003);
}
// TODO: Load column ids instead of names
}
private void LoadPrefixMap(Cursor dataTableCursor)
{
// Find the Schema Naming Context by its objectCategory
dataTableCursor.CurrentIndex = this.FindIndexName(CommonDirectoryAttributes.ObjectCategory);
int schemaObjectCategoryId = this.FindClassId(CommonDirectoryClasses.Schema);
bool schemaFound = dataTableCursor.GotoKey(Key.Compose(schemaObjectCategoryId));
// Load the prefix map from this object
var prefixMapColId = this.FindColumnId(CommonDirectoryAttributes.PrefixMap);
byte[] binaryPrefixMap = dataTableCursor.RetrieveColumnAsByteArray(prefixMapColId);
this.PrefixMapper = new PrefixMap(binaryPrefixMap);
foreach(var attribute in this.attributesByName.Values)
{
if (attribute.Id.HasValue)
{
attribute.Oid = this.PrefixMapper.Translate((uint)attribute.Id.Value);
}
}
}
private void LoadClassList(Cursor dataTableCursor)
{
// Initialize the class list
this.classesByName = new Dictionary<string, int>();
// Load column IDs
Columnid ldapDisplayNameCol = this.FindColumnId(CommonDirectoryAttributes.LDAPDisplayName);
Columnid dntCol = this.FindColumnId(CommonDirectoryAttributes.DNTag);
// Search for all classes
dataTableCursor.CurrentIndex = this.FindIndexName(CommonDirectoryAttributes.ObjectClass);
dataTableCursor.FindRecords(MatchCriteria.EqualTo, Key.Compose(CommonDirectoryClasses.ClassSchemaId));
while (dataTableCursor.MoveNext())
{
// TODO: Load more data about classes
int classId = dataTableCursor.RetrieveColumnAsDNTag(dntCol).Value;
string className = dataTableCursor.RetrieveColumnAsString(ldapDisplayNameCol);
classesByName.Add(className, classId);
}
}
private Columnid LoadColumnIdByAttributeName(Cursor cursor, string attributeName)
{
Columnid attributeIdCol = this.attributesByInternalId[CommonDirectoryAttributes.AttributeIdId].ColumnID;
// Assume that attributeNameIndex is set as the current index
cursor.GotoKey(Key.Compose(attributeName));
int attributeId = cursor.RetrieveColumnAsInt(attributeIdCol).Value;
return this.attributesByInternalId[attributeId].ColumnID;
}
private void LoadAttributeProperties(Cursor dataTableCursor)
{
// With these built-in attributes, ID == Internal ID
Columnid attributeIdCol = this.attributesByInternalId[CommonDirectoryAttributes.AttributeIdId].ColumnID;
SchemaAttribute ldapDisplayNameAtt = this.attributesByInternalId[CommonDirectoryAttributes.LdapDisplayNameId];
Columnid ldapDisplayNameCol = ldapDisplayNameAtt.ColumnID;
// Set index to ldapDisplayName so that we can find attributes by their name
dataTableCursor.CurrentIndex = ldapDisplayNameAtt.Index;
// Load attribute ids of attributeSchema attributes by doing DB lookups
// TODO: Hardcode IDs of these attributes so that we do not have to do DB lookups?
Columnid internalIdCol = this.LoadColumnIdByAttributeName(dataTableCursor, CommonDirectoryAttributes.InternalId);
Columnid linkIdCol = this.LoadColumnIdByAttributeName(dataTableCursor, CommonDirectoryAttributes.LinkId);
Columnid isSingleValuedCol = this.LoadColumnIdByAttributeName(dataTableCursor, CommonDirectoryAttributes.IsSingleValued);
Columnid attributeSyntaxCol = this.LoadColumnIdByAttributeName(dataTableCursor, CommonDirectoryAttributes.AttributeSyntax);
Columnid isInGlobalCatalogCol = this.LoadColumnIdByAttributeName(dataTableCursor, CommonDirectoryAttributes.IsInGlobalCatalog);
Columnid searchFlagsCol = this.LoadColumnIdByAttributeName(dataTableCursor, CommonDirectoryAttributes.SearchFlags);
Columnid systemOnlyCol = this.LoadColumnIdByAttributeName(dataTableCursor, CommonDirectoryAttributes.SystemOnly);
Columnid syntaxCol = this.LoadColumnIdByAttributeName(dataTableCursor, CommonDirectoryAttributes.AttributeSyntax);
Columnid omSyntaxCol = this.LoadColumnIdByAttributeName(dataTableCursor, CommonDirectoryAttributes.AttributeOmSyntax);
Columnid cnCol = this.LoadColumnIdByAttributeName(dataTableCursor, CommonDirectoryAttributes.CommonName);
Columnid rangeLowerCol = this.LoadColumnIdByAttributeName(dataTableCursor, CommonDirectoryAttributes.RangeLower);
Columnid rangeUpperCol = this.LoadColumnIdByAttributeName(dataTableCursor, CommonDirectoryAttributes.RangeUpper);
Columnid schemaGuidCol = this.LoadColumnIdByAttributeName(dataTableCursor, CommonDirectoryAttributes.SchemaGuid);
Columnid systemFlagsCol = this.LoadColumnIdByAttributeName(dataTableCursor, CommonDirectoryAttributes.SystemFlags);
Columnid isDefunctCol = this.LoadColumnIdByAttributeName(dataTableCursor, CommonDirectoryAttributes.IsDefunct);
// Now traverse through all schema attributes and load their properties
dataTableCursor.CurrentIndex = this.attributesByInternalId[CommonDirectoryAttributes.ObjectClassId].Index;
dataTableCursor.FindRecords(MatchCriteria.EqualTo, Key.Compose(CommonDirectoryClasses.AttributeSchemaId));
while (dataTableCursor.MoveNext())
{
int? internalId = dataTableCursor.RetrieveColumnAsInt(internalIdCol);
int attributeId = dataTableCursor.RetrieveColumnAsInt(attributeIdCol).Value;
// Some built-in attributes do not have internal id set, which meand it is equal to the public id
int id = internalId ?? attributeId;
SchemaAttribute attribute;
bool found = this.attributesByInternalId.TryGetValue(id, out attribute);
if (! found)
{
// Load info about a new attribute
attribute = new SchemaAttribute();
attribute.InternalId = internalId;
}
attribute.Id = dataTableCursor.RetrieveColumnAsInt(attributeIdCol).Value;
attribute.Name = dataTableCursor.RetrieveColumnAsString(ldapDisplayNameCol);
attribute.CommonName = dataTableCursor.RetrieveColumnAsString(cnCol);
attribute.RangeLower = dataTableCursor.RetrieveColumnAsInt(rangeLowerCol);
attribute.RangeUpper = dataTableCursor.RetrieveColumnAsInt(rangeUpperCol);
attribute.SchemaGuid = dataTableCursor.RetrieveColumnAsGuid(schemaGuidCol).Value;
attribute.IsDefunct = dataTableCursor.RetrieveColumnAsBoolean(isDefunctCol);
attribute.SystemFlags = dataTableCursor.RetrieveColumnAsAttributeSystemFlags(systemFlagsCol);
attribute.LinkId = dataTableCursor.RetrieveColumnAsInt(linkIdCol);
attribute.IsInGlobalCatalog = dataTableCursor.RetrieveColumnAsBoolean(isInGlobalCatalogCol);
attribute.IsSingleValued = dataTableCursor.RetrieveColumnAsBoolean(isSingleValuedCol);
attribute.SearchFlags = dataTableCursor.RetrieveColumnAsSearchFlags(searchFlagsCol);
attribute.IsSystemOnly = dataTableCursor.RetrieveColumnAsBoolean(systemOnlyCol);
attribute.Syntax = dataTableCursor.RetrieveColumnAsAttributeSyntax(syntaxCol);
attribute.OmSyntax = dataTableCursor.RetrieveColumnAsAttributeOmSyntax(omSyntaxCol);
// Make it case-insensitive by always lowering the name:
this.attributesByName.Add(attribute.Name.ToLower(), attribute);
}
}
public SecurityDescriptorRersolver(IsamDatabase database)
{
this.cursor = database.OpenCursor(ADConstants.SecurityDescriptorTableName);
this.cursor.SetCurrentIndex(SdIndex);
}
protected virtual void Dispose(bool disposing)
{
if (disposing && cursor != null)
{
cursor.Dispose();
cursor = null;
}
}
private void LoadClassList(Cursor dataTableCursor)
{
// Initialize the class list
this.classesByName = new Dictionary<string, int>();
// Load column IDs. We are in an early stage of schema loading, which means that we cannot search for non-system attributes by name.
Columnid dntCol = this.FindColumnId(CommonDirectoryAttributes.DNTag);
Columnid governsIdCol = this.attributesByInternalId[CommonDirectoryAttributes.GovernsIdId].ColumnID;
SchemaAttribute ldapDisplayNameAtt = this.attributesByInternalId[CommonDirectoryAttributes.LdapDisplayNameId];
// Search for all classes using this heuristics: (&(ldapDisplayName=*)(governsId=*))
dataTableCursor.CurrentIndex = ldapDisplayNameAtt.Index;
while (dataTableCursor.MoveNext())
{
int? governsId = dataTableCursor.RetrieveColumnAsInt(governsIdCol);
if(!governsId.HasValue)
{
// This is an attribute and not a class, so we skip to the next object.
continue;
}
// TODO: Load more data about classes
int classDNT = dataTableCursor.RetrieveColumnAsDNTag(dntCol).Value;
string className = dataTableCursor.RetrieveColumnAsString(ldapDisplayNameAtt.ColumnID);
classesByName.Add(className, classDNT);
}
}
public DistinguishedNameResolver(IsamDatabase database, DirectorySchema schema)
{
this.dnCache = new Dictionary<int, string>();
this.schema = schema;
this.cursor = database.OpenCursor(ADConstants.DataTableName);
}
/// <summary>
/// Initializes a new instance of the <see cref="CursorEnumerator"/> class.
/// </summary>
/// <param name="cursor">The cursor.</param>
internal CursorEnumerator(Cursor cursor)
{
this.cursor = cursor;
}
public DomainController(DirectoryContext context)
{
// TODO: Split to different methods.
// Open the hiddentable
this.systemTableCursor = context.OpenSystemTable();
// Go to the first and only record in the hiddentable:
this.systemTableCursor.MoveToFirst();
// Load attributes from the hiddentable:
this.NTDSSettingsDNT = this.systemTableCursor.RetrieveColumnAsInt(ntdsSettingsCol).Value;
if(this.systemTableCursor.TableDefinition.Columns.Contains(osVersionMajorCol))
{
// Some databases like the initial adamntds.dit or ntds.dit on Windows Server 2003 do not contain the OS Version
this.OSVersionMinor = this.systemTableCursor.RetrieveColumnAsUInt(osVersionMinorCol);
this.OSVersionMajor = this.systemTableCursor.RetrieveColumnAsUInt(osVersionMajorCol);
}
if (this.systemTableCursor.TableDefinition.Columns.Contains(epochCol))
{
// This is a new feature since Windows Server 2008
this.epochCache = this.systemTableCursor.RetrieveColumnAsInt(epochCol);
}
if (this.systemTableCursor.TableDefinition.Columns.Contains(usnAtIfmCol))
{
this.UsnAtIfm = this.systemTableCursor.RetrieveColumnAsLong(usnAtIfmCol);
}
this.BackupExpiration = this.systemTableCursor.RetrieveColumnAsGeneralizedTime(backupExpirationCol);
this.BackupUsn = this.systemTableCursor.RetrieveColumnAsLong(backupUsnCol);
this.State = (DatabaseState) this.systemTableCursor.RetrieveColumnAsInt(stateCol).Value;
byte[] binaryFlags = this.systemTableCursor.RetrieveColumnAsByteArray(flagsCol);
var databaseFlags = new DatabaseFlags(binaryFlags);
this.IsADAM = databaseFlags.ADAMDatabase;
// TODO: Export other database flags, not just IsADAM.
// TODO: Load database health
this.highestUSNCache = this.systemTableCursor.RetrieveColumnAsLong(highestCommitedUsnCol).Value;
// Now we can load the Invocation ID and other information from the datatable:
using (var dataTableCursor = context.OpenDataTable())
{
// Goto NTDS Settings object:
DirectorySchema schema = context.Schema;
dataTableCursor.CurrentIndex = schema.FindIndexName(CommonDirectoryAttributes.DNTag);
bool ntdsFound = dataTableCursor.GotoKey(Key.Compose(this.NTDSSettingsDNT));
// Load data from the NTDS Settings object
this.InvocationId = dataTableCursor.RetrieveColumnAsGuid(schema.FindColumnId(CommonDirectoryAttributes.InvocationId)).Value;
this.DsaGuid = dataTableCursor.RetrieveColumnAsGuid(schema.FindColumnId(CommonDirectoryAttributes.ObjectGUID)).Value;
this.Options = dataTableCursor.RetrieveColumnAsDomainControllerOptions(schema.FindColumnId(CommonDirectoryAttributes.Options));
string ntdsName = dataTableCursor.RetrieveColumnAsString(schema.FindColumnId(CommonDirectoryAttributes.CommonName));
// Retrieve Configuration Naming Context
this.ConfigurationNamingContextDNT = dataTableCursor.RetrieveColumnAsDNTag(schema.FindColumnId(CommonDirectoryAttributes.NamingContextDNTag)).Value;
this.ConfigurationNamingContext = context.DistinguishedNameResolver.Resolve(this.ConfigurationNamingContextDNT);
// Retrieve Schema Naming Context
this.SchemaNamingContextDNT = dataTableCursor.RetrieveColumnAsDNTag(schema.FindColumnId(CommonDirectoryAttributes.SchemaLocation)).Value;
this.SchemaNamingContext = context.DistinguishedNameResolver.Resolve(this.SchemaNamingContextDNT);
// Goto DC object (parent of NTDS):
bool dcFound = dataTableCursor.GotoToParentObject(schema);
// Load data from the DC object
// Load DC name:
string dcName = dataTableCursor.RetrieveColumnAsString(schema.FindColumnId(CommonDirectoryAttributes.CommonName));
// DC name is null in the initial database, so use NTDS Settings object's CN instead
this.Name = dcName ?? ntdsName;
// Load DNS Host Name
this.DNSHostName = dataTableCursor.RetrieveColumnAsString(schema.FindColumnId(CommonDirectoryAttributes.DNSHostName));
// Load server reference to domain partition:
int dcDNTag = dataTableCursor.RetrieveColumnAsDNTag(schema.FindColumnId(CommonDirectoryAttributes.DNTag)).Value;
this.ServerReferenceDNT = context.LinkResolver.GetLinkedDNTag(dcDNTag, CommonDirectoryAttributes.ServerReference);
// Goto Servers object (parent of DC):
bool serversFound = dataTableCursor.GotoToParentObject(schema);
// Goto Site object (parent of servers):
bool siteFound = dataTableCursor.GotoToParentObject(schema);
// Load data from the Site object
if(siteFound)
{
this.SiteName = dataTableCursor.RetrieveColumnAsString(schema.FindColumnId(CommonDirectoryAttributes.CommonName));
}
// Load partitions (linked multivalue attribute)
// TODO: Does not return PAS partitions on RODCs
IEnumerable<int> partitionDNTags = context.LinkResolver.GetLinkedDNTags(this.NTDSSettingsDNT, CommonDirectoryAttributes.MasterNamingContexts);
this.WritablePartitions = context.DistinguishedNameResolver.Resolve(partitionDNTags).Select(dn => dn.ToString()).ToArray();
// Load domain (linked multivalue attribute)
// TODO: Test this against a GC and RODC:
this.DomainNamingContextDNT = context.LinkResolver.GetLinkedDNTag(this.NTDSSettingsDNT, CommonDirectoryAttributes.DomainNamingContexts);
if (this.DomainNamingContextDNT.HasValue)
{
// Move cursor to domain:
bool domainObjectFound = dataTableCursor.GotoKey(Key.Compose(this.DomainNamingContextDNT.Value));
// Load domain SID
this.DomainSid = dataTableCursor.RetrieveColumnAsSid(schema.FindColumnId(CommonDirectoryAttributes.ObjectSid));
// Load domain naming context:
this.DomainNamingContext = context.DistinguishedNameResolver.Resolve(this.DomainNamingContextDNT.Value);
}
// Goto server object in domain partition
if (this.ServerReferenceDNT.HasValue)
{
bool serverFound = dataTableCursor.GotoKey(Key.Compose(this.ServerReferenceDNT.Value));
this.OSName = dataTableCursor.RetrieveColumnAsString(schema.FindColumnId(CommonDirectoryAttributes.OperatingSystemName));
this.ServerReference = context.DistinguishedNameResolver.Resolve(this.ServerReferenceDNT.Value);
}
}
}
/// <summary>
/// Releases unmanaged and - optionally - managed resources.
/// </summary>
/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
if (this.systemTableCursor != null)
{
this.systemTableCursor.Dispose();
this.systemTableCursor = null;
}
}
}
protected virtual void Dispose(bool disposing)
{
if (!disposing)
{
return;
}
if (this.dataTableCursor != null)
{
this.dataTableCursor.Dispose();
this.dataTableCursor = null;
}
if (this.ownsContext && this.context != null)
{
this.context.Dispose();
this.context = null;
}
}
public DirectoryAgent(DirectoryContext context, bool ownsContext = false)
{
this.context = context;
this.ownsContext = ownsContext;
this.dataTableCursor = context.OpenDataTable();
}
