protected void WriteAttrib(string attrName, ADAttribute attrib, XmlWriter mXmlWriter, string strNamespace)
{
if (strNamespace != null)
{
mXmlWriter.WriteStartElement(attrName, strNamespace);
}
else
{
mXmlWriter.WriteStartElement(attrName);
}
mXmlWriter.WriteAttributeString("name", attrib.Name);
foreach (ADValue value2 in attrib.Values)
{
this.WriteValue("value", value2, mXmlWriter, strNamespace);
}
mXmlWriter.WriteEndElement();
}
protected void WriteAttrib(string attrName, ADAttribute attrib, XmlWriter mXmlWriter, string strNamespace)
{
if (strNamespace != null)
{
mXmlWriter.WriteStartElement(attrName, strNamespace);
}
else
{
mXmlWriter.WriteStartElement(attrName);
}
mXmlWriter.WriteAttributeString("name", attrib.Name);
foreach (ADValue value2 in attrib.Values)
{
this.WriteValue("value", value2, mXmlWriter, strNamespace);
}
mXmlWriter.WriteEndElement();
}
protected void WriteAttrib(string attrName, ADAttribute attrib, XmlWriter mXmlWriter, string strNamespace)
{
if (strNamespace != null)
{
mXmlWriter.WriteStartElement(attrName, strNamespace);
}
else
{
mXmlWriter.WriteStartElement(attrName);
}
mXmlWriter.WriteAttributeString(DsmlConstants.AttrDsmlAttrName, attrib.Name);
foreach (ADValue val in attrib.Values)
{
WriteValue(DsmlConstants.ElementDsmlAttrValue, val, mXmlWriter, strNamespace);
}
mXmlWriter.WriteEndElement();
}
protected void WriteAttrib(string attrName, ADAttribute attrib, XmlWriter mXmlWriter, string strNamespace)
{
if (strNamespace != null)
{
mXmlWriter.WriteStartElement(attrName, strNamespace);
}
else
{
mXmlWriter.WriteStartElement(attrName);
}
mXmlWriter.WriteAttributeString(DsmlConstants.AttrDsmlAttrName, attrib.Name);
foreach (ADValue val in attrib.Values)
{
WriteValue(DsmlConstants.ElementDsmlAttrValue, val, mXmlWriter, strNamespace);
}
mXmlWriter.WriteEndElement();
}
public static ADFilter ParseFilterString(string filter)
{
Debug.Assert(filter != null);
//perfomr the matthing. On success all info we are interested in
//will be stored in the named captures.
try
{
Match m = s_mFilter.Match(filter);
if (!m.Success)
{
return null;
}
ADFilter result = new ADFilter();
if (m.Groups["item"].ToString().Length != 0)
{
//we have am "item"filter which can be
//of type "present", "simple", "substring", or "extensible"
if (m.Groups["present"].ToString().Length != 0)
{
//present filter, e.g. (objectClass=*)
result.Type = ADFilter.FilterType.Present;
Debug.Assert(m.Groups["presentattr"].ToString().Length != 0);
result.Filter.Present = m.Groups["presentattr"].ToString();
}
else if (m.Groups["simple"].ToString().Length != 0)
{
//simple filter, e.g. (simpleattr =|~=|>=|<= simplevalue)
ADAttribute simple = new ADAttribute();
if (m.Groups["simplevalue"].ToString().Length != 0)
{
ADValue val = StringFilterValueToADValue(m.Groups["simplevalue"].ToString());
simple.Values.Add(val);
}
simple.Name = m.Groups["simpleattr"].ToString();
//the variours types of relationships we might have
switch (m.Groups["filtertype"].ToString())
{
case "=":
result.Type = ADFilter.FilterType.EqualityMatch;
result.Filter.EqualityMatch = simple;
break;
case "~=":
result.Type = ADFilter.FilterType.ApproxMatch;
result.Filter.ApproxMatch = simple;
break;
case "<=":
result.Type = ADFilter.FilterType.LessOrEqual;
result.Filter.LessOrEqual = simple;
break;
case ">=":
result.Type = ADFilter.FilterType.GreaterOrEqual;
result.Filter.GreaterOrEqual = simple;
break;
default:
//this should not occur
Debug.Fail("FilterParser.ParseFilterString: Invalid simple filter");
//treat like a parse error
return null;
}
}
else if (m.Groups["substr"].ToString().Length != 0)
{
//we have a substring filter. Get the various parts of it
result.Type = ADFilter.FilterType.Substrings;
ADSubstringFilter substr = new ADSubstringFilter();
substr.Initial = StringFilterValueToADValue(m.Groups["initialvalue"].ToString());
substr.Final = StringFilterValueToADValue(m.Groups["finalvalue"].ToString());
if (m.Groups["anyvalue"].ToString().Length != 0)
{
foreach (Capture c in m.Groups["anyvalue"].Captures)
{
substr.Any.Add(StringFilterValueToADValue(c.ToString()));
}
}
substr.Name = m.Groups["substrattr"].ToString();
result.Filter.Substrings = substr;
}
else if (m.Groups["extensible"].ToString().Length != 0)
{
//extensible filter
result.Type = ADFilter.FilterType.ExtensibleMatch;
ADExtenMatchFilter exten = new ADExtenMatchFilter();
exten.Value = StringFilterValueToADValue(m.Groups["extenvalue"].ToString());
exten.DNAttributes = (m.Groups["dnattr"].ToString().Length != 0);
exten.Name = m.Groups["extenattr"].ToString();
exten.MatchingRule = m.Groups["matchrule"].ToString();
result.Filter.ExtensibleMatch = exten;
}
else
{
//this should not occur
Debug.Fail("Invalid item filter");
//treat like a parse error
return null;
}
}
else
{
//compound recursive filter
//extract the filter lists
ArrayList filters = new ArrayList();
string filterList = m.Groups["filterlist"].ToString().Trim();
while (filterList.Length > 0)
{
if (filterList[0] != '(')
{
//this is a parse error: invalid filter
return null;
}
int strIdx = 1;
int left = 1; //count opening brackest
bool gotSubfilter = false;
while (strIdx < filterList.Length && !gotSubfilter)
{
if (filterList[strIdx] == '(')
{
left++;
}
if (filterList[strIdx] == ')')
{
if (left < 1)
{
//unbalanced parenthesis
return null;
}
else if (left == 1)
{
//the end of the subfilter
gotSubfilter = true;
}
else
{
left--;
}
}
strIdx++;
}
if (!gotSubfilter)
{
//the filter list did not consist entirely of subfilters
return null;
}
filters.Add(filterList.Substring(0, strIdx));
filterList = filterList.Substring(strIdx).TrimStart();
}
ADFilter eltFilter = null;
switch (m.Groups["filtercomp"].ToString())
{
case "|":
result.Type = ADFilter.FilterType.Or;
result.Filter.Or = new ArrayList();
foreach (String f in filters)
{
eltFilter = ParseFilterString(f);
if (eltFilter == null)
{
return null;
}
result.Filter.Or.Add(eltFilter);
}
if (result.Filter.Or.Count < 1)
{
return null;
}
break;
case "&":
result.Type = ADFilter.FilterType.And;
result.Filter.And = new ArrayList();
foreach (String f in filters)
{
eltFilter = ParseFilterString(f);
if (eltFilter == null)
{
return null;
}
result.Filter.And.Add(eltFilter);
}
if (result.Filter.And.Count < 1)
{
return null;
}
break;
case "!":
result.Type = ADFilter.FilterType.Not;
eltFilter = ParseFilterString((string)filters[0]);
//Note that for ease of defining the filter grammar we allow
//more than one filter after '!'. We catch this here
if (filters.Count > 1 || eltFilter == null)
{
return null;
}
result.Filter.Not = eltFilter;
break;
default:
//this should not occur
Debug.Fail("Invalid filter composition");
//treat like a parse error
return null;
}
}
return result;
}//end of try
catch (RegexMatchTimeoutException)
{
Debug.WriteLine("The input filter String: {0} exceeded the regex match timeout of {1} seconds.", filter, mFilterTimeOutInSeconds);
return null;
}
}
public static ADFilter ParseFilterString(string filter)
{
Match match = mFilter.Match(filter);
if (match.Success)
{
ADFilter filter2 = new ADFilter();
if (match.Groups["item"].ToString().Length == 0)
{
int num;
ArrayList list = new ArrayList();
for (string str = match.Groups["filterlist"].ToString().Trim(); str.Length > 0; str = str.Substring(num).TrimStart(new char[0]))
{
if (str[0] != '(')
{
return(null);
}
num = 1;
int num2 = 1;
bool flag = false;
while ((num < str.Length) && !flag)
{
if (str[num] == '(')
{
num2++;
}
if (str[num] == ')')
{
if (num2 < 1)
{
return(null);
}
if (num2 == 1)
{
flag = true;
}
else
{
num2--;
}
}
num++;
}
if (!flag)
{
return(null);
}
list.Add(str.Substring(0, num));
}
ADFilter filter5 = null;
switch (match.Groups["filtercomp"].ToString())
{
case "|":
filter2.Type = ADFilter.FilterType.Or;
filter2.Filter.Or = new ArrayList();
foreach (string str2 in list)
{
filter5 = ParseFilterString(str2);
if (filter5 == null)
{
return(null);
}
filter2.Filter.Or.Add(filter5);
}
if (filter2.Filter.Or.Count >= 1)
{
return(filter2);
}
return(null);
case "&":
filter2.Type = ADFilter.FilterType.And;
filter2.Filter.And = new ArrayList();
foreach (string str3 in list)
{
filter5 = ParseFilterString(str3);
if (filter5 == null)
{
return(null);
}
filter2.Filter.And.Add(filter5);
}
if (filter2.Filter.And.Count >= 1)
{
return(filter2);
}
return(null);
case "!":
filter2.Type = ADFilter.FilterType.Not;
filter5 = ParseFilterString((string)list[0]);
if ((list.Count > 1) || (filter5 == null))
{
return(null);
}
filter2.Filter.Not = filter5;
return(filter2);
}
return(null);
}
if (match.Groups["present"].ToString().Length != 0)
{
filter2.Type = ADFilter.FilterType.Present;
filter2.Filter.Present = match.Groups["presentattr"].ToString();
return(filter2);
}
if (match.Groups["simple"].ToString().Length == 0)
{
if (match.Groups["substr"].ToString().Length != 0)
{
filter2.Type = ADFilter.FilterType.Substrings;
ADSubstringFilter filter3 = new ADSubstringFilter {
Initial = StringFilterValueToADValue(match.Groups["initialvalue"].ToString()),
Final = StringFilterValueToADValue(match.Groups["finalvalue"].ToString())
};
if (match.Groups["anyvalue"].ToString().Length != 0)
{
foreach (Capture capture in match.Groups["anyvalue"].Captures)
{
filter3.Any.Add(StringFilterValueToADValue(capture.ToString()));
}
}
filter3.Name = match.Groups["substrattr"].ToString();
filter2.Filter.Substrings = filter3;
return(filter2);
}
if (match.Groups["extensible"].ToString().Length != 0)
{
filter2.Type = ADFilter.FilterType.ExtensibleMatch;
ADExtenMatchFilter filter4 = new ADExtenMatchFilter {
Value = StringFilterValueToADValue(match.Groups["extenvalue"].ToString()),
DNAttributes = match.Groups["dnattr"].ToString().Length != 0,
Name = match.Groups["extenattr"].ToString(),
MatchingRule = match.Groups["matchrule"].ToString()
};
filter2.Filter.ExtensibleMatch = filter4;
return(filter2);
}
return(null);
}
ADAttribute attribute = new ADAttribute();
if (match.Groups["simplevalue"].ToString().Length != 0)
{
ADValue value2 = StringFilterValueToADValue(match.Groups["simplevalue"].ToString());
attribute.Values.Add(value2);
}
attribute.Name = match.Groups["simpleattr"].ToString();
switch (match.Groups["filtertype"].ToString())
{
case "=":
filter2.Type = ADFilter.FilterType.EqualityMatch;
filter2.Filter.EqualityMatch = attribute;
return(filter2);
case "~=":
filter2.Type = ADFilter.FilterType.ApproxMatch;
filter2.Filter.ApproxMatch = attribute;
return(filter2);
case "<=":
filter2.Type = ADFilter.FilterType.LessOrEqual;
filter2.Filter.LessOrEqual = attribute;
return(filter2);
case ">=":
filter2.Type = ADFilter.FilterType.GreaterOrEqual;
filter2.Filter.GreaterOrEqual = attribute;
return(filter2);
}
}
return(null);
}
public static ADFilter ParseFilterString(string filter)
{
Match match = mFilter.Match(filter);
if (match.Success)
{
ADFilter filter2 = new ADFilter();
if (match.Groups["item"].ToString().Length == 0)
{
int num;
ArrayList list = new ArrayList();
for (string str = match.Groups["filterlist"].ToString().Trim(); str.Length > 0; str = str.Substring(num).TrimStart(new char[0]))
{
if (str[0] != '(')
{
return null;
}
num = 1;
int num2 = 1;
bool flag = false;
while ((num < str.Length) && !flag)
{
if (str[num] == '(')
{
num2++;
}
if (str[num] == ')')
{
if (num2 < 1)
{
return null;
}
if (num2 == 1)
{
flag = true;
}
else
{
num2--;
}
}
num++;
}
if (!flag)
{
return null;
}
list.Add(str.Substring(0, num));
}
ADFilter filter5 = null;
switch (match.Groups["filtercomp"].ToString())
{
case "|":
filter2.Type = ADFilter.FilterType.Or;
filter2.Filter.Or = new ArrayList();
foreach (string str2 in list)
{
filter5 = ParseFilterString(str2);
if (filter5 == null)
{
return null;
}
filter2.Filter.Or.Add(filter5);
}
if (filter2.Filter.Or.Count >= 1)
{
return filter2;
}
return null;
case "&":
filter2.Type = ADFilter.FilterType.And;
filter2.Filter.And = new ArrayList();
foreach (string str3 in list)
{
filter5 = ParseFilterString(str3);
if (filter5 == null)
{
return null;
}
filter2.Filter.And.Add(filter5);
}
if (filter2.Filter.And.Count >= 1)
{
return filter2;
}
return null;
case "!":
filter2.Type = ADFilter.FilterType.Not;
filter5 = ParseFilterString((string) list[0]);
if ((list.Count > 1) || (filter5 == null))
{
return null;
}
filter2.Filter.Not = filter5;
return filter2;
}
return null;
}
if (match.Groups["present"].ToString().Length != 0)
{
filter2.Type = ADFilter.FilterType.Present;
filter2.Filter.Present = match.Groups["presentattr"].ToString();
return filter2;
}
if (match.Groups["simple"].ToString().Length == 0)
{
if (match.Groups["substr"].ToString().Length != 0)
{
filter2.Type = ADFilter.FilterType.Substrings;
ADSubstringFilter filter3 = new ADSubstringFilter {
Initial = StringFilterValueToADValue(match.Groups["initialvalue"].ToString()),
Final = StringFilterValueToADValue(match.Groups["finalvalue"].ToString())
};
if (match.Groups["anyvalue"].ToString().Length != 0)
{
foreach (Capture capture in match.Groups["anyvalue"].Captures)
{
filter3.Any.Add(StringFilterValueToADValue(capture.ToString()));
}
}
filter3.Name = match.Groups["substrattr"].ToString();
filter2.Filter.Substrings = filter3;
return filter2;
}
if (match.Groups["extensible"].ToString().Length != 0)
{
filter2.Type = ADFilter.FilterType.ExtensibleMatch;
ADExtenMatchFilter filter4 = new ADExtenMatchFilter {
Value = StringFilterValueToADValue(match.Groups["extenvalue"].ToString()),
DNAttributes = match.Groups["dnattr"].ToString().Length != 0,
Name = match.Groups["extenattr"].ToString(),
MatchingRule = match.Groups["matchrule"].ToString()
};
filter2.Filter.ExtensibleMatch = filter4;
return filter2;
}
return null;
}
ADAttribute attribute = new ADAttribute();
if (match.Groups["simplevalue"].ToString().Length != 0)
{
ADValue value2 = StringFilterValueToADValue(match.Groups["simplevalue"].ToString());
attribute.Values.Add(value2);
}
attribute.Name = match.Groups["simpleattr"].ToString();
switch (match.Groups["filtertype"].ToString())
{
case "=":
filter2.Type = ADFilter.FilterType.EqualityMatch;
filter2.Filter.EqualityMatch = attribute;
return filter2;
case "~=":
filter2.Type = ADFilter.FilterType.ApproxMatch;
filter2.Filter.ApproxMatch = attribute;
return filter2;
case "<=":
filter2.Type = ADFilter.FilterType.LessOrEqual;
filter2.Filter.LessOrEqual = attribute;
return filter2;
case ">=":
filter2.Type = ADFilter.FilterType.GreaterOrEqual;
filter2.Filter.GreaterOrEqual = attribute;
return filter2;
}
}
return null;
}
public static ADFilter ParseFilterString(string filter)
{
Debug.Assert(filter != null);
//perfomr the matthing. On success all info we are interested in
//will be stored in the named captures.
try
{
Match m = s_mFilter.Match(filter);
if (!m.Success)
{
return(null);
}
ADFilter result = new ADFilter();
if (m.Groups["item"].ToString().Length != 0)
{
//we have am "item"filter which can be
//of type "present", "simple", "substring", or "extensible"
if (m.Groups["present"].ToString().Length != 0)
{
//present filter, e.g. (objectClass=*)
result.Type = ADFilter.FilterType.Present;
Debug.Assert(m.Groups["presentattr"].ToString().Length != 0);
result.Filter.Present = m.Groups["presentattr"].ToString();
}
else if (m.Groups["simple"].ToString().Length != 0)
{
//simple filter, e.g. (simpleattr =|~=|>=|<= simplevalue)
ADAttribute simple = new ADAttribute();
if (m.Groups["simplevalue"].ToString().Length != 0)
{
ADValue val = StringFilterValueToADValue(m.Groups["simplevalue"].ToString());
simple.Values.Add(val);
}
simple.Name = m.Groups["simpleattr"].ToString();
//the variours types of relationships we might have
switch (m.Groups["filtertype"].ToString())
{
case "=":
result.Type = ADFilter.FilterType.EqualityMatch;
result.Filter.EqualityMatch = simple;
break;
case "~=":
result.Type = ADFilter.FilterType.ApproxMatch;
result.Filter.ApproxMatch = simple;
break;
case "<=":
result.Type = ADFilter.FilterType.LessOrEqual;
result.Filter.LessOrEqual = simple;
break;
case ">=":
result.Type = ADFilter.FilterType.GreaterOrEqual;
result.Filter.GreaterOrEqual = simple;
break;
default:
//this should not occur
Debug.Fail("FilterParser.ParseFilterString: Invalid simple filter");
//treat like a parse error
return(null);
}
}
else if (m.Groups["substr"].ToString().Length != 0)
{
//we have a substring filter. Get the various parts of it
result.Type = ADFilter.FilterType.Substrings;
ADSubstringFilter substr = new ADSubstringFilter();
substr.Initial = StringFilterValueToADValue(m.Groups["initialvalue"].ToString());
substr.Final = StringFilterValueToADValue(m.Groups["finalvalue"].ToString());
if (m.Groups["anyvalue"].ToString().Length != 0)
{
foreach (Capture c in m.Groups["anyvalue"].Captures)
{
substr.Any.Add(StringFilterValueToADValue(c.ToString()));
}
}
substr.Name = m.Groups["substrattr"].ToString();
result.Filter.Substrings = substr;
}
else if (m.Groups["extensible"].ToString().Length != 0)
{
//extensible filter
result.Type = ADFilter.FilterType.ExtensibleMatch;
ADExtenMatchFilter exten = new ADExtenMatchFilter();
exten.Value = StringFilterValueToADValue(m.Groups["extenvalue"].ToString());
exten.DNAttributes = (m.Groups["dnattr"].ToString().Length != 0);
exten.Name = m.Groups["extenattr"].ToString();
exten.MatchingRule = m.Groups["matchrule"].ToString();
result.Filter.ExtensibleMatch = exten;
}
else
{
//this should not occur
Debug.Fail("Invalid item filter");
//treat like a parse error
return(null);
}
}
else
{
//compound recursive filter
//extract the filter lists
ArrayList filters = new ArrayList();
string filterList = m.Groups["filterlist"].ToString().Trim();
while (filterList.Length > 0)
{
if (filterList[0] != '(')
{
//this is a parse error: invalid filter
return(null);
}
int strIdx = 1;
int left = 1; //count opening brackest
bool gotSubfilter = false;
while (strIdx < filterList.Length && !gotSubfilter)
{
if (filterList[strIdx] == '(')
{
left++;
}
if (filterList[strIdx] == ')')
{
if (left < 1)
{
//unbalanced parenthesis
return(null);
}
else if (left == 1)
{
//the end of the subfilter
gotSubfilter = true;
}
else
{
left--;
}
}
strIdx++;
}
if (!gotSubfilter)
{
//the filter list did not consist entirely of subfilters
return(null);
}
filters.Add(filterList.Substring(0, strIdx));
filterList = filterList.Substring(strIdx).TrimStart();
}
ADFilter eltFilter = null;
switch (m.Groups["filtercomp"].ToString())
{
case "|":
result.Type = ADFilter.FilterType.Or;
result.Filter.Or = new ArrayList();
foreach (String f in filters)
{
eltFilter = ParseFilterString(f);
if (eltFilter == null)
{
return(null);
}
result.Filter.Or.Add(eltFilter);
}
if (result.Filter.Or.Count < 1)
{
return(null);
}
break;
case "&":
result.Type = ADFilter.FilterType.And;
result.Filter.And = new ArrayList();
foreach (String f in filters)
{
eltFilter = ParseFilterString(f);
if (eltFilter == null)
{
return(null);
}
result.Filter.And.Add(eltFilter);
}
if (result.Filter.And.Count < 1)
{
return(null);
}
break;
case "!":
result.Type = ADFilter.FilterType.Not;
eltFilter = ParseFilterString((string)filters[0]);
//Note that for ease of defining the filter grammar we allow
//more than one filter after '!'. We catch this here
if (filters.Count > 1 || eltFilter == null)
{
return(null);
}
result.Filter.Not = eltFilter;
break;
default:
//this should not occur
Debug.Fail("Invalid filter composition");
//treat like a parse error
return(null);
}
}
return(result);
}//end of try
catch (RegexMatchTimeoutException)
{
Debug.WriteLine("The input filter String: {0} exceeded the regex match timeout of {1} seconds.", filter, mFilterTimeOutInSeconds);
return(null);
}
}
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);
}
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;
}