protected override XmlElement ToXmlNode(XmlDocument doc)
{
string str;
XmlElement xmlElement = base.CreateRequestElement(doc, "searchRequest", true, this.dn);
XmlAttribute xmlAttribute = doc.CreateAttribute("scope", null);
SearchScope searchScope = this.directoryScope;
switch (searchScope)
{
case SearchScope.Base:
{
xmlAttribute.InnerText = "baseObject";
break;
}
case SearchScope.OneLevel:
{
xmlAttribute.InnerText = "singleLevel";
break;
}
case SearchScope.Subtree:
{
xmlAttribute.InnerText = "wholeSubtree";
break;
}
}
xmlElement.Attributes.Append(xmlAttribute);
XmlAttribute xmlAttribute1 = doc.CreateAttribute("derefAliases", null);
DereferenceAlias dereferenceAlia = this.directoryRefAlias;
switch (dereferenceAlia)
{
case DereferenceAlias.Never:
{
xmlAttribute1.InnerText = "neverDerefAliases";
break;
}
case DereferenceAlias.InSearching:
{
xmlAttribute1.InnerText = "derefInSearching";
break;
}
case DereferenceAlias.FindingBaseObject:
{
xmlAttribute1.InnerText = "derefFindingBaseObj";
break;
}
case DereferenceAlias.Always:
{
xmlAttribute1.InnerText = "derefAlways";
break;
}
}
xmlElement.Attributes.Append(xmlAttribute1);
XmlAttribute str1 = doc.CreateAttribute("sizeLimit", null);
str1.InnerText = this.directorySizeLimit.ToString(CultureInfo.InvariantCulture);
xmlElement.Attributes.Append(str1);
XmlAttribute str2 = doc.CreateAttribute("timeLimit", null);
long ticks = this.directoryTimeLimit.Ticks / (long)0x989680;
str2.InnerText = ticks.ToString(CultureInfo.InvariantCulture);
xmlElement.Attributes.Append(str2);
XmlAttribute xmlAttribute2 = doc.CreateAttribute("typesOnly", null);
XmlAttribute xmlAttribute3 = xmlAttribute2;
if (this.directoryTypesOnly)
{
str = "true";
}
else
{
str = "false";
}
xmlAttribute3.InnerText = str;
xmlElement.Attributes.Append(xmlAttribute2);
XmlElement outerXml = doc.CreateElement("filter", "urn:oasis:names:tc:DSML:2:0:core");
if (this.Filter == null)
{
outerXml.InnerXml = "<present name='objectClass' xmlns=\"urn:oasis:names:tc:DSML:2:0:core\"/>";
}
else
{
StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture);
XmlTextWriter xmlTextWriter = new XmlTextWriter(stringWriter);
try
{
if (this.Filter as XmlDocument == null)
{
if (this.Filter as string != null)
{
string filter = (string)this.Filter;
if (!filter.StartsWith("(", StringComparison.Ordinal) && !filter.EndsWith(")", StringComparison.Ordinal))
{
filter = filter.Insert(0, "(");
filter = string.Concat(filter, ")");
}
ADFilter aDFilter = FilterParser.ParseFilterString(filter);
if (aDFilter != null)
{
DSMLFilterWriter dSMLFilterWriter = new DSMLFilterWriter();
dSMLFilterWriter.WriteFilter(aDFilter, false, xmlTextWriter, "urn:oasis:names:tc:DSML:2:0:core");
outerXml.InnerXml = stringWriter.ToString();
}
else
{
throw new ArgumentException(Res.GetString("BadSearchLDAPFilter"));
}
}
}
else
{
if (((XmlDocument)this.Filter).NamespaceURI.Length != 0)
{
outerXml.InnerXml = ((XmlDocument)this.Filter).OuterXml;
}
else
{
this.CopyFilter((XmlDocument)this.Filter, xmlTextWriter);
outerXml.InnerXml = stringWriter.ToString();
}
}
}
finally
{
xmlTextWriter.Close();
}
}
xmlElement.AppendChild(outerXml);
if (this.directoryAttributes != null && this.directoryAttributes.Count != 0)
{
XmlElement xmlElement1 = doc.CreateElement("attributes", "urn:oasis:names:tc:DSML:2:0:core");
xmlElement.AppendChild(xmlElement1);
foreach (string directoryAttribute in this.directoryAttributes)
{
DirectoryAttribute directoryAttribute1 = new DirectoryAttribute();
directoryAttribute1.Name = directoryAttribute;
XmlElement xmlNode = directoryAttribute1.ToXmlNode(doc, "attribute");
xmlElement1.AppendChild(xmlNode);
}
}
return(xmlElement);
}
protected override XmlElement ToXmlNode(XmlDocument doc)
{
XmlElement elem = CreateRequestElement(doc, "searchRequest", true, _dn);
// attach the "scope" attribute (required)
XmlAttribute attrScope = doc.CreateAttribute("scope", null);
switch (_directoryScope)
{
case SearchScope.Subtree:
attrScope.InnerText = "wholeSubtree";
break;
case SearchScope.OneLevel:
attrScope.InnerText = "singleLevel";
break;
case SearchScope.Base:
attrScope.InnerText = "baseObject";
break;
default:
Debug.Assert(false, "Unknown DsmlSearchScope type");
break;
}
elem.Attributes.Append(attrScope);
// attach the "derefAliases" attribute (required)
XmlAttribute attrDerefAliases = doc.CreateAttribute("derefAliases", null);
switch (_directoryRefAlias)
{
case DereferenceAlias.Never:
attrDerefAliases.InnerText = "neverDerefAliases";
break;
case DereferenceAlias.InSearching:
attrDerefAliases.InnerText = "derefInSearching";
break;
case DereferenceAlias.FindingBaseObject:
attrDerefAliases.InnerText = "derefFindingBaseObj";
break;
case DereferenceAlias.Always:
attrDerefAliases.InnerText = "derefAlways";
break;
default:
Debug.Assert(false, "Unknown DsmlDereferenceAlias type");
break;
}
elem.Attributes.Append(attrDerefAliases);
// attach the "sizeLimit" attribute (optional)
XmlAttribute attrSizeLimit = doc.CreateAttribute("sizeLimit", null);
attrSizeLimit.InnerText = _directorySizeLimit.ToString(CultureInfo.InvariantCulture);
elem.Attributes.Append(attrSizeLimit);
// attach the "timeLimit" attribute (optional)
XmlAttribute attrTimeLimit = doc.CreateAttribute("timeLimit", null);
attrTimeLimit.InnerText = (_directoryTimeLimit.Ticks / TimeSpan.TicksPerSecond).ToString(CultureInfo.InvariantCulture);
elem.Attributes.Append(attrTimeLimit);
// attach the "typesOnly" attribute (optional, defaults to false)
XmlAttribute attrTypesOnly = doc.CreateAttribute("typesOnly", null);
attrTypesOnly.InnerText = _directoryTypesOnly ? "true" : "false";
elem.Attributes.Append(attrTypesOnly);
// add in the <filter> element (required)
XmlElement elemFilter = doc.CreateElement("filter", DsmlConstants.DsmlUri);
if (Filter != null)
{
StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture);
XmlTextWriter xmlWriter = new XmlTextWriter(stringWriter);
try
{
if (Filter is XmlDocument)
{
if (((XmlDocument)Filter).NamespaceURI.Length == 0)
{
// namespaceURI is not explicitly specified
CopyFilter((XmlDocument)Filter, xmlWriter);
elemFilter.InnerXml = stringWriter.ToString();
}
else
{
elemFilter.InnerXml = ((XmlDocument)Filter).OuterXml;
}
}
else if (Filter is string)
{
//
// Search Filter
// We make use of the code from DSDE, which requires an intermediary
// trip through the ADFilter representation. Although ADFilter is unnecessary
// for our purposes, this enables us to use the same exact code as
// DSDE, without having to maintain a second copy of it.
//
// AD filter currently does not support filter without paranthesis, so adding it explicitly
string tempFilter = (string)Filter;
if (!tempFilter.StartsWith("(", StringComparison.Ordinal) && !tempFilter.EndsWith(")", StringComparison.Ordinal))
{
tempFilter = tempFilter.Insert(0, "(");
tempFilter = String.Concat(tempFilter, ")");
}
// Convert LDAP filter string to ADFilter representation
ADFilter adfilter = FilterParser.ParseFilterString(tempFilter);
if (adfilter == null)
{
// The LDAP filter string didn't parse correctly
throw new ArgumentException(Res.GetString(Res.BadSearchLDAPFilter));
}
// Convert ADFilter representation to a DSML filter string
// Ideally, we'd skip the intemediary string, but the DSDE conversion
// routines expect a XmlWriter, and the only XmlWriter available
// is the XmlTextWriter, which produces text.
DSMLFilterWriter filterwriter = new DSMLFilterWriter();
filterwriter.WriteFilter(adfilter, false, xmlWriter, DsmlConstants.DsmlUri);
elemFilter.InnerXml = stringWriter.ToString();
}
else
{
Debug.Assert(false, "Unknown filter type");
}
}
finally
{
// close this stream and the underlying stream.
xmlWriter.Close();
}
}
else
{
// default filter: (objectclass=*)
elemFilter.InnerXml = DsmlConstants.DefaultSearchFilter;
}
elem.AppendChild(elemFilter);
// add in the <attributes> element (optional)
if (_directoryAttributes != null && _directoryAttributes.Count != 0)
{
// create and attach the <attributes> element
XmlElement elemAttributes = doc.CreateElement("attributes", DsmlConstants.DsmlUri);
elem.AppendChild(elemAttributes);
// create and attach the <attribute> elements under the <attributes> element
foreach (string attrName in _directoryAttributes)
{
// DsmlAttribute objects know how to persist themself in the right
// XML format, so we'll make use of that here rather than
// duplicating the code
DirectoryAttribute attr = new DirectoryAttribute();
attr.Name = attrName;
XmlElement elemAttr = attr.ToXmlNode(doc, "attribute");
elemAttributes.AppendChild(elemAttr);
}
}
return(elem);
}
protected override XmlElement ToXmlNode(XmlDocument doc)
{
XmlElement element = base.CreateRequestElement(doc, "searchRequest", true, this.dn);
XmlAttribute node = doc.CreateAttribute("scope", null);
switch (this.directoryScope)
{
case SearchScope.Base:
node.InnerText = "baseObject";
break;
case SearchScope.OneLevel:
node.InnerText = "singleLevel";
break;
case SearchScope.Subtree:
node.InnerText = "wholeSubtree";
break;
}
element.Attributes.Append(node);
XmlAttribute attribute2 = doc.CreateAttribute("derefAliases", null);
switch (this.directoryRefAlias)
{
case DereferenceAlias.Never:
attribute2.InnerText = "neverDerefAliases";
break;
case DereferenceAlias.InSearching:
attribute2.InnerText = "derefInSearching";
break;
case DereferenceAlias.FindingBaseObject:
attribute2.InnerText = "derefFindingBaseObj";
break;
case DereferenceAlias.Always:
attribute2.InnerText = "derefAlways";
break;
}
element.Attributes.Append(attribute2);
XmlAttribute attribute3 = doc.CreateAttribute("sizeLimit", null);
attribute3.InnerText = this.directorySizeLimit.ToString(CultureInfo.InvariantCulture);
element.Attributes.Append(attribute3);
XmlAttribute attribute4 = doc.CreateAttribute("timeLimit", null);
attribute4.InnerText = (this.directoryTimeLimit.Ticks / 0x989680L).ToString(CultureInfo.InvariantCulture);
element.Attributes.Append(attribute4);
XmlAttribute attribute5 = doc.CreateAttribute("typesOnly", null);
attribute5.InnerText = this.directoryTypesOnly ? "true" : "false";
element.Attributes.Append(attribute5);
XmlElement newChild = doc.CreateElement("filter", "urn:oasis:names:tc:DSML:2:0:core");
if (this.Filter != null)
{
StringWriter w = new StringWriter(CultureInfo.InvariantCulture);
XmlTextWriter writer = new XmlTextWriter(w);
try
{
if (this.Filter is XmlDocument)
{
if (((XmlDocument)this.Filter).NamespaceURI.Length == 0)
{
this.CopyFilter((XmlDocument)this.Filter, writer);
newChild.InnerXml = w.ToString();
}
else
{
newChild.InnerXml = ((XmlDocument)this.Filter).OuterXml;
}
}
else if (this.Filter is string)
{
string str = (string)this.Filter;
if (!str.StartsWith("(", StringComparison.Ordinal) && !str.EndsWith(")", StringComparison.Ordinal))
{
str = str.Insert(0, "(") + ")";
}
ADFilter filter = FilterParser.ParseFilterString(str);
if (filter == null)
{
throw new ArgumentException(System.DirectoryServices.Protocols.Res.GetString("BadSearchLDAPFilter"));
}
new DSMLFilterWriter().WriteFilter(filter, false, writer, "urn:oasis:names:tc:DSML:2:0:core");
newChild.InnerXml = w.ToString();
}
}
finally
{
writer.Close();
}
}
else
{
newChild.InnerXml = "<present name='objectClass' xmlns=\"urn:oasis:names:tc:DSML:2:0:core\"/>";
}
element.AppendChild(newChild);
if ((this.directoryAttributes != null) && (this.directoryAttributes.Count != 0))
{
XmlElement element3 = doc.CreateElement("attributes", "urn:oasis:names:tc:DSML:2:0:core");
element.AppendChild(element3);
foreach (string str2 in this.directoryAttributes)
{
XmlElement element4 = new DirectoryAttribute {
Name = str2
}.ToXmlNode(doc, "attribute");
element3.AppendChild(element4);
}
}
return(element);
}
public static ADFilter ParseFilterString(string filter)
{
ADFilter aDFilter = null;
ADFilter aDFilter1 = null;
try
{
Match match = FilterParser.mFilter.Match(filter);
if (match.Success)
{
ADFilter arrayLists = new ADFilter();
if (match.Groups["item"].ToString().Length == 0)
{
ArrayList arrayLists1 = new ArrayList();
string str = match.Groups["filterlist"].ToString().Trim();
while (str.Length > 0)
{
if (str[0] == '(')
{
int num = 1;
int num1 = 1;
bool flag = false;
while (num < str.Length && !flag)
{
if (str[num] == '(')
{
num1++;
}
if (str[num] == ')')
{
if (num1 >= 1)
{
if (num1 != 1)
{
num1--;
}
else
{
flag = true;
}
}
else
{
aDFilter1 = null;
return(aDFilter1);
}
}
num++;
}
if (flag)
{
arrayLists1.Add(str.Substring(0, num));
str = str.Substring(num).TrimStart(new char[0]);
}
else
{
aDFilter1 = null;
return(aDFilter1);
}
}
else
{
aDFilter1 = null;
return(aDFilter1);
}
}
string str1 = match.Groups["filtercomp"].ToString();
string str2 = str1;
if (str1 != null)
{
if (str2 == "|")
{
arrayLists.Type = ADFilter.FilterType.Or;
arrayLists.Filter.Or = new ArrayList();
foreach (string arrayList in arrayLists1)
{
aDFilter = FilterParser.ParseFilterString(arrayList);
if (aDFilter != null)
{
arrayLists.Filter.Or.Add(aDFilter);
}
else
{
aDFilter1 = null;
return(aDFilter1);
}
}
if (arrayLists.Filter.Or.Count < 1)
{
aDFilter1 = null;
return(aDFilter1);
}
else
{
goto Label1;
}
}
else
{
if (str2 == "&")
{
arrayLists.Type = ADFilter.FilterType.And;
arrayLists.Filter.And = new ArrayList();
foreach (string arrayList1 in arrayLists1)
{
aDFilter = FilterParser.ParseFilterString(arrayList1);
if (aDFilter != null)
{
arrayLists.Filter.And.Add(aDFilter);
}
else
{
aDFilter1 = null;
return(aDFilter1);
}
}
if (arrayLists.Filter.And.Count < 1)
{
aDFilter1 = null;
return(aDFilter1);
}
else
{
goto Label1;
}
}
else
{
if (str2 != "!")
{
aDFilter1 = null;
return(aDFilter1);
}
arrayLists.Type = ADFilter.FilterType.Not;
aDFilter = FilterParser.ParseFilterString((string)arrayLists1[0]);
if (arrayLists1.Count > 1 || aDFilter == null)
{
aDFilter1 = null;
return(aDFilter1);
}
else
{
arrayLists.Filter.Not = aDFilter;
goto Label1;
}
}
}
}
aDFilter1 = null;
return(aDFilter1);
}
else
{
if (match.Groups["present"].ToString().Length == 0)
{
if (match.Groups["simple"].ToString().Length == 0)
{
if (match.Groups["substr"].ToString().Length == 0)
{
if (match.Groups["extensible"].ToString().Length == 0)
{
aDFilter1 = null;
return(aDFilter1);
}
else
{
arrayLists.Type = ADFilter.FilterType.ExtensibleMatch;
ADExtenMatchFilter aDExtenMatchFilter = new ADExtenMatchFilter();
aDExtenMatchFilter.Value = FilterParser.StringFilterValueToADValue(match.Groups["extenvalue"].ToString());
aDExtenMatchFilter.DNAttributes = match.Groups["dnattr"].ToString().Length != 0;
aDExtenMatchFilter.Name = match.Groups["extenattr"].ToString();
aDExtenMatchFilter.MatchingRule = match.Groups["matchrule"].ToString();
arrayLists.Filter.ExtensibleMatch = aDExtenMatchFilter;
}
}
else
{
arrayLists.Type = ADFilter.FilterType.Substrings;
ADSubstringFilter aDSubstringFilter = new ADSubstringFilter();
aDSubstringFilter.Initial = FilterParser.StringFilterValueToADValue(match.Groups["initialvalue"].ToString());
aDSubstringFilter.Final = FilterParser.StringFilterValueToADValue(match.Groups["finalvalue"].ToString());
if (match.Groups["anyvalue"].ToString().Length != 0)
{
foreach (Capture capture in match.Groups["anyvalue"].Captures)
{
aDSubstringFilter.Any.Add(FilterParser.StringFilterValueToADValue(capture.ToString()));
}
}
aDSubstringFilter.Name = match.Groups["substrattr"].ToString();
arrayLists.Filter.Substrings = aDSubstringFilter;
}
}
else
{
ADAttribute aDAttribute = new ADAttribute();
if (match.Groups["simplevalue"].ToString().Length != 0)
{
ADValue aDValue = FilterParser.StringFilterValueToADValue(match.Groups["simplevalue"].ToString());
aDAttribute.Values.Add(aDValue);
}
aDAttribute.Name = match.Groups["simpleattr"].ToString();
string str3 = match.Groups["filtertype"].ToString();
string str4 = str3;
if (str3 != null)
{
if (str4 == "=")
{
arrayLists.Type = ADFilter.FilterType.EqualityMatch;
arrayLists.Filter.EqualityMatch = aDAttribute;
goto Label1;
}
else
{
if (str4 == "~=")
{
arrayLists.Type = ADFilter.FilterType.ApproxMatch;
arrayLists.Filter.ApproxMatch = aDAttribute;
goto Label1;
}
else
{
if (str4 == "<=")
{
arrayLists.Type = ADFilter.FilterType.LessOrEqual;
arrayLists.Filter.LessOrEqual = aDAttribute;
goto Label1;
}
else
{
if (str4 != ">=")
{
aDFilter1 = null;
return(aDFilter1);
}
arrayLists.Type = ADFilter.FilterType.GreaterOrEqual;
arrayLists.Filter.GreaterOrEqual = aDAttribute;
goto Label1;
}
}
}
}
aDFilter1 = null;
return(aDFilter1);
}
}
else
{
arrayLists.Type = ADFilter.FilterType.Present;
arrayLists.Filter.Present = match.Groups["presentattr"].ToString();
}
}
Label1:
aDFilter1 = arrayLists;
}
else
{
aDFilter1 = null;
}
}
catch (Exception regexMatchTimeoutException)
{
aDFilter1 = null;
}
return(aDFilter1);
}
