/// <summary> /// Queries for directory entries matching a given filter up to a specified count /// </summary> /// <param name="count">The number of entries to find (-1 for no limit)</param> /// <returns>A SearchResultCollection containing matching directory entries</returns> public SearchResultCollection FindAll(int count) { // Always load ADsPath so that DirectoryEntry entities can be created if (!PropertiesToLoad.Contains("ADsPath")) { PropertiesToLoad.Add("ADsPath"); } // Create an LDAP SearchRequest using the root's name and the provided filter, scope, and properties var req = new SearchRequest(SearchRoot.DistinguishedName, Filter, SearchScope, PropertiesToLoad.ToArray()); if (count > 0) { // Limit the result size, if necessary req.SizeLimit = count; } // Use the SearchRoot's connection since it should already exist. var res = SearchRoot.Connection.SendRequest(req) as SearchResponse; if (res.ResultCode != ResultCode.Success) { throw new InvalidOperationException($"Error connecting to Active Directory: {res.ResultCode.ToString()}: {res.ErrorMessage}"); } // Create and return a SearchResultCollection with the returned entries return(new SearchResultCollection(SearchRoot, res.Entries, PropertiesToLoad)); }
/// <summary> /// Initializes a new instance of the DirectorySearcher class with /// SearchRoot set to its default value. Filter, PropertiesToLoad, /// and SearchScope are set to the specified values /// </summary> /// <param name="filter"> /// The search filter string in Lightweight Directory Access Protocol /// (Ldap) format. The Filter property is initialized to this value. /// </param> /// <param name="propertiesToLoad"> /// The set of properties to retrieve during the search. The /// PropertiesToLoad property is initialized to this value. /// </param> /// <param name="scope"> /// The scope of the search that is observed by the server. The /// SearchScope property is initialized to this value. /// </param> public DirectorySearcher(string filter, string[] propertiesToLoad, SearchScope scope) { _SearchScope = scope; _Filter = filter; PropertiesToLoad.AddRange(propertiesToLoad); }
/// <summary> /// Initializes a new instance of the DirectorySearcher class with /// SearchScope set to its default value. SearchRoot, Filter, and /// PropertiesToLoad are set to the specified values. /// </summary> /// <param name="searchRoot"> /// The node in the Active Directory hierarchy where the search starts. /// The SearchRoot property is initialized to this value /// </param> /// <param name="filter"> /// The search filter string in Lightweight Directory Access Protocol /// (Ldap) format. The Filter property is initialized to this value. /// </param> /// <param name="propertiesToLoad"> /// The set of properties retrieved during the search. The /// PropertiesToLoad property is initialized to this value. /// </param> public DirectorySearcher(DirectoryEntry searchRoot, string filter, string[] propertiesToLoad) { _SearchRoot = searchRoot; _Filter = filter; PropertiesToLoad.AddRange(propertiesToLoad); }
/// <include file='doc\DirectorySearcher.uex' path='docs/doc[@for="DirectorySearcher.DirectorySearcher7"]/*' /> /// <devdoc> /// <para>Initializes a new instance of the <see cref='System.DirectoryServices.DirectorySearcher'/> class with the <see cref='System.DirectoryServices.DirectorySearcher.SearchRoot'/>, <see cref='System.DirectoryServices.DirectorySearcher.Filter'/>, <see cref='System.DirectoryServices.DirectorySearcher.PropertiesToLoad'/>, and <see cref='System.DirectoryServices.DirectorySearcher.SearchScope'/> properties set to the given /// values.</para> /// </devdoc> public DirectorySearcher(DirectoryEntry searchRoot, string filter, string[] propertiesToLoad, SearchScope scope) { this.searchRoot = searchRoot; this.filter = filter; if (propertiesToLoad != null) { PropertiesToLoad.AddRange(propertiesToLoad); } this.SearchScope = scope; }
public PrincipalSearcher(DomainPath domainPath, DirectoryEntry searchRoot, ICollection <string> additionalPropertyNames = null) : base(searchRoot) { this.domainPath = domainPath; this.additionalPropertyNames = additionalPropertyNames; PropertiesToLoad.Add(ActiveDirectoryProperties.ObjectGuid); PropertiesToLoad.Add(ActiveDirectoryProperties.DisplayName); PropertiesToLoad.Add(ActiveDirectoryProperties.Member); PropertiesToLoad.Add(ActiveDirectoryProperties.MemberOf); if (additionalPropertyNames != null) { foreach (string propertyName in additionalPropertyNames) { PropertiesToLoad.Add(propertyName); } } }
public SearchResultCollection FindAll(int count) { // TODO - Do something with count if (!PropertiesToLoad.Contains("ADsPath")) { PropertiesToLoad.Add("ADsPath"); } SearchRequest req = new SearchRequest(SearchRoot.DistinguishedName, Filter, SearchScope, PropertiesToLoad.ToArray()); // Use the SearchRoot's connection since it should already exist. // TODO - Learn more about AD to understand if it's better to create a new connection or to use an existing one. var res = SearchRoot.Connection.SendRequest(req) as SearchResponse; if (res.ResultCode != ResultCode.Success) { throw new InvalidOperationException($"Error connecting to Active Directory: {res.ResultCode.ToString()}: {res.ErrorMessage}"); } return(new SearchResultCollection(SearchRoot, res.Entries, PropertiesToLoad)); }
private SearchResultCollection FindAll(bool findMoreThanOne) { //if it is not of valid searching type, then throw an exception if (SearchRoot == null) { Version adsVersion = GetAdsVersion(); throw new InvalidOperationException(Res.GetString(Res.DSVersion, adsVersion.ToString())); } DirectoryEntry clonedRoot = null; if (assertDefaultNamingContext == null) { clonedRoot = SearchRoot.CloneBrowsable(); } else { //SECREVIEW: If the SearchRoot was created by this object // it is safe to assert its browse permission to get // the inner IAds. DirectoryServicesPermission dsPermission = new DirectoryServicesPermission( DirectoryServicesPermissionAccess.Browse, assertDefaultNamingContext); dsPermission.Assert(); try { clonedRoot = SearchRoot.CloneBrowsable(); } finally { DirectoryServicesPermission.RevertAssert(); } } UnsafeNativeMethods.IAds adsObject = clonedRoot.AdsObject; if (!(adsObject is UnsafeNativeMethods.IDirectorySearch)) { throw new NotSupportedException(Res.GetString(Res.DSSearchUnsupported, SearchRoot.Path)); } UnsafeNativeMethods.IDirectorySearch adsSearch = (UnsafeNativeMethods.IDirectorySearch)adsObject; SetSearchPreferences(adsSearch, findMoreThanOne); string[] properties = null; if (PropertiesToLoad.Count > 0) { if (!PropertiesToLoad.Contains("ADsPath")) { // if we don't get this property, we won't be able to return a list of DirectoryEntry objects! PropertiesToLoad.Add("ADsPath"); } properties = new string[PropertiesToLoad.Count]; PropertiesToLoad.CopyTo(properties, 0); } IntPtr resultsHandle; if (properties != null) { adsSearch.ExecuteSearch(Filter, properties, properties.Length, out resultsHandle); } else { adsSearch.ExecuteSearch(Filter, null, -1, out resultsHandle); properties = new string[0]; } SearchResultCollection result = new SearchResultCollection(clonedRoot, resultsHandle, properties, Filter); return(result); }
private void DoSearch() { InitBlock(); String[] attrs = new String[PropertiesToLoad.Count]; PropertiesToLoad.CopyTo(attrs, 0); LdapSearchConstraints cons = _conn.SearchConstraints; if (SizeLimit > 0) { cons.MaxResults = SizeLimit; } if (ServerTimeLimit != DefaultTimeSpan) { cons.ServerTimeLimit = (int)ServerTimeLimit.TotalSeconds; } int connScope = LdapConnection.SCOPE_SUB; switch (_SearchScope) { case SearchScope.Base: connScope = LdapConnection.SCOPE_BASE; break; case SearchScope.OneLevel: connScope = LdapConnection.SCOPE_ONE; break; case SearchScope.Subtree: connScope = LdapConnection.SCOPE_SUB; break; default: connScope = LdapConnection.SCOPE_SUB; break; } LdapSearchResults lsc = _conn.Search(SearchRoot.Fdn, connScope, Filter, attrs, PropertyNamesOnly, cons); while (lsc.hasMore()) { LdapEntry nextEntry = null; try { nextEntry = lsc.next(); } catch (LdapException e) { switch (e.ResultCode) { // in case of this return codes exception should not be thrown case LdapException.SIZE_LIMIT_EXCEEDED: case LdapException.TIME_LIMIT_EXCEEDED: case LdapException.REFERRAL: continue; default: throw e; } } DirectoryEntry de = new DirectoryEntry(_conn); PropertyCollection pcoll = new PropertyCollection(); // de.SetProperties(); de.Path = DirectoryEntry.GetLdapUrlString(_Host, _Port, nextEntry.DN); LdapAttributeSet attributeSet = nextEntry.getAttributeSet(); System.Collections.IEnumerator ienum = attributeSet.GetEnumerator(); if (ienum != null) { while (ienum.MoveNext()) { LdapAttribute attribute = (LdapAttribute)ienum.Current; string attributeName = attribute.Name; pcoll[attributeName].AddRange(attribute.StringValueArray); // de.Properties[attributeName].AddRange(attribute.StringValueArray); // de.Properties[attributeName].Mbit=false; } } if (!pcoll.Contains("ADsPath")) { pcoll["ADsPath"].Add(de.Path); } // _SrchColl.Add(new SearchResult(de,PropertiesToLoad)); _SrchColl.Add(new SearchResult(de, pcoll)); } return; }
/// <summary> /// Initializes a new instance of the DirectorySearcher class with /// SearchRoot and SearchScope set to the default values. Filter and /// PropertiesToLoad are set to the specified values. /// </summary> /// <param name="filter"> /// The search filter string in Lightweight Directory Access Protocol /// (Ldap) format. The Filter property is initialized to this value. /// </param> /// <param name="propertiesToLoad"> /// The set of properties to retrieve during the search. The /// PropertiesToLoad property is initialized to this value. /// </param> public DirectorySearcher(string filter, string[] propertiesToLoad) { _Filter = filter; PropertiesToLoad.AddRange(propertiesToLoad); }
public System.Data.DataTable GetQueryDataTable() { System.Data.DataTable dt = new System.Data.DataTable(); List <string> propertiesToLoad = new List <string>(); if (PropertiesToLoad == null || PropertiesToLoad.Trim().Length == 0) { propertiesToLoad.Add("sAMAccountName"); dt.Columns.Add(new System.Data.DataColumn("sAMAccountName", typeof(string))); } else { foreach (string propName in PropertiesToLoad.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries)) { propertiesToLoad.Add(propName.Trim()); dt.Columns.Add(new System.Data.DataColumn(propName.Trim(), typeof(string))); } } if (QueryFilterText == null || QueryFilterText.Trim().Length == 0) { return(dt); } string formattedFilterText = FormatQueryFilter(QueryFilterText); if (formattedFilterText.Contains("%")) { formattedFilterText = MacroVariables.FormatVariables(formattedFilterText); } //int lineCount = 0; DirectoryEntry entryRoot = GetADRoot(); using (DirectorySearcher searcher = new DirectorySearcher(entryRoot, formattedFilterText)) { searcher.PropertiesToLoad.AddRange(propertiesToLoad.ToArray()); searcher.SizeLimit = 1000; searcher.PageSize = 1000; SearchResultCollection matches = searcher.FindAll(); foreach (SearchResult match in matches) { List <string> rowValues = new List <string>(); foreach (string propName in propertiesToLoad) { string propertyValue = ""; try { if (match.Properties.Contains(propName)) { if (match.Properties[propName].Count > 0 && match.Properties[propName] != null) { propertyValue = match.Properties[propName][0].ToString(); } else { propertyValue = "N/A"; } } else { propertyValue = "N/A"; } } catch { propertyValue = "err"; } rowValues.Add(propertyValue); } dt.Rows.Add(rowValues.ToArray()); //lineCount++; //if (lineCount >= MaxRowsToEvaluate) // break; } } return(dt); }
//For Collector testing purposes only the first MaxRowsToEvaluate number of returned records are used unless UseRowCountAsValue is true. public object RunQuery() { object returnValue = null; if (QueryFilterText == null || QueryFilterText.Trim().Length == 0) { return(null); } string formattedFilterText = FormatQueryFilter(QueryFilterText); if (formattedFilterText.Contains("%")) { formattedFilterText = MacroVariables.FormatVariables(formattedFilterText); } DirectoryEntry entryRoot = GetADRoot(); using (DirectorySearcher searcher = new DirectorySearcher(entryRoot, formattedFilterText)) { List <string> propertiesToLoad = new List <string>(); if (PropertiesToLoad == null || PropertiesToLoad.Trim().Length == 0) { propertiesToLoad.Add("sAMAccountName"); } else { foreach (string propName in PropertiesToLoad.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries)) { propertiesToLoad.Add(propName.Trim()); } } searcher.PropertiesToLoad.AddRange(propertiesToLoad.ToArray()); searcher.SizeLimit = 1000; searcher.PageSize = 1000; SearchResultCollection matches = searcher.FindAll(); if (UseRowCountAsValue) { returnValue = matches.Count; } else { StringBuilder lines = new StringBuilder(); int lineCount = 0; foreach (SearchResult match in matches) { StringBuilder line = new StringBuilder(); foreach (string propName in propertiesToLoad) { string propertyValue = ""; try { if (match.Properties.Contains(propName)) { if (match.Properties[propName].Count > 0 && match.Properties[propName] != null) { propertyValue = match.Properties[propName][0].ToString(); } else { propertyValue = "N/A"; } } else { propertyValue = "N/A"; } } catch { propertyValue = "err"; } line.Append(propertyValue + ","); } lines.AppendLine(line.ToString().Trim(',')); lineCount++; if (lineCount >= MaxRowsToEvaluate) { break; } } returnValue = lines.ToString(); } } return(returnValue); }
private void NewPropertyToLoad(string propertyName) { PropertiesToLoad.Clear(); PropertiesToLoad.Add(propertyName); }