Exemplo n.º 1
0
        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;
            }
        }
Exemplo n.º 2
0
        public void WriteFilter(ADFilter filter, bool filterTags, XmlWriter mXmlWriter, string strNamespace)
        {
            if (filterTags)
            {
                if (strNamespace != null)
                {
                    mXmlWriter.WriteStartElement("filter", strNamespace);
                }
                else
                {
                    mXmlWriter.WriteStartElement("filter");
                }
            }
            switch (filter.Type)
            {
            case ADFilter.FilterType.And:
                if (strNamespace == null)
                {
                    mXmlWriter.WriteStartElement("and");
                    break;
                }
                mXmlWriter.WriteStartElement("and", strNamespace);
                break;

            case ADFilter.FilterType.Or:
                if (strNamespace == null)
                {
                    mXmlWriter.WriteStartElement("or");
                }
                else
                {
                    mXmlWriter.WriteStartElement("or", strNamespace);
                }
                foreach (object obj3 in filter.Filter.Or)
                {
                    this.WriteFilter((ADFilter)obj3, false, mXmlWriter, strNamespace);
                }
                mXmlWriter.WriteEndElement();
                goto Label_03E0;

            case ADFilter.FilterType.Not:
                if (strNamespace == null)
                {
                    mXmlWriter.WriteStartElement("not");
                }
                else
                {
                    mXmlWriter.WriteStartElement("not", strNamespace);
                }
                this.WriteFilter(filter.Filter.Not, false, mXmlWriter, strNamespace);
                mXmlWriter.WriteEndElement();
                goto Label_03E0;

            case ADFilter.FilterType.EqualityMatch:
                this.WriteAttrib("equalityMatch", filter.Filter.EqualityMatch, mXmlWriter, strNamespace);
                goto Label_03E0;

            case ADFilter.FilterType.Substrings:
            {
                ADSubstringFilter substrings = filter.Filter.Substrings;
                if (strNamespace == null)
                {
                    mXmlWriter.WriteStartElement("substrings");
                }
                else
                {
                    mXmlWriter.WriteStartElement("substrings", strNamespace);
                }
                mXmlWriter.WriteAttributeString("name", substrings.Name);
                if (substrings.Initial != null)
                {
                    this.WriteValue("initial", substrings.Initial, mXmlWriter, strNamespace);
                }
                if (substrings.Any != null)
                {
                    foreach (object obj4 in substrings.Any)
                    {
                        this.WriteValue("any", (ADValue)obj4, mXmlWriter, strNamespace);
                    }
                }
                if (substrings.Final != null)
                {
                    this.WriteValue("final", substrings.Final, mXmlWriter, strNamespace);
                }
                mXmlWriter.WriteEndElement();
                goto Label_03E0;
            }

            case ADFilter.FilterType.GreaterOrEqual:
                this.WriteAttrib("greaterOrEqual", filter.Filter.GreaterOrEqual, mXmlWriter, strNamespace);
                goto Label_03E0;

            case ADFilter.FilterType.LessOrEqual:
                this.WriteAttrib("lessOrEqual", filter.Filter.LessOrEqual, mXmlWriter, strNamespace);
                goto Label_03E0;

            case ADFilter.FilterType.Present:
                if (strNamespace == null)
                {
                    mXmlWriter.WriteStartElement("present");
                }
                else
                {
                    mXmlWriter.WriteStartElement("present", strNamespace);
                }
                mXmlWriter.WriteAttributeString("name", filter.Filter.Present);
                mXmlWriter.WriteEndElement();
                goto Label_03E0;

            case ADFilter.FilterType.ApproxMatch:
                this.WriteAttrib("approxMatch", filter.Filter.ApproxMatch, mXmlWriter, strNamespace);
                goto Label_03E0;

            case ADFilter.FilterType.ExtensibleMatch:
            {
                ADExtenMatchFilter extensibleMatch = filter.Filter.ExtensibleMatch;
                if (strNamespace == null)
                {
                    mXmlWriter.WriteStartElement("extensibleMatch");
                }
                else
                {
                    mXmlWriter.WriteStartElement("extensibleMatch", strNamespace);
                }
                if ((extensibleMatch.Name != null) && (extensibleMatch.Name.Length != 0))
                {
                    mXmlWriter.WriteAttributeString("name", extensibleMatch.Name);
                }
                if ((extensibleMatch.MatchingRule != null) && (extensibleMatch.MatchingRule.Length != 0))
                {
                    mXmlWriter.WriteAttributeString("matchingRule", extensibleMatch.MatchingRule);
                }
                mXmlWriter.WriteAttributeString("dnAttributes", XmlConvert.ToString(extensibleMatch.DNAttributes));
                this.WriteValue("value", extensibleMatch.Value, mXmlWriter, strNamespace);
                mXmlWriter.WriteEndElement();
                goto Label_03E0;
            }

            default:
                throw new ArgumentException(System.DirectoryServices.Protocols.Res.GetString("InvalidFilterType", new object[] { filter.Type }));
            }
            foreach (object obj2 in filter.Filter.And)
            {
                this.WriteFilter((ADFilter)obj2, false, mXmlWriter, strNamespace);
            }
            mXmlWriter.WriteEndElement();
Label_03E0:
            if (filterTags)
            {
                mXmlWriter.WriteEndElement();
            }
        }
Exemplo n.º 3
0
        public void WriteFilter(ADFilter filter, bool filterTags, XmlWriter mXmlWriter, string strNamespace)
        {
            if (filterTags)
            {
                if (strNamespace != null)
                {
                    mXmlWriter.WriteStartElement(DsmlConstants.ElementSearchReqFilter, strNamespace);
                }
                else
                {
                    mXmlWriter.WriteStartElement(DsmlConstants.ElementSearchReqFilter);
                }
            }

            switch (filter.Type)
            {
            case ADFilter.FilterType.And:
                if (strNamespace != null)
                {
                    mXmlWriter.WriteStartElement(DsmlConstants.ElementSearchReqFilterAnd, strNamespace);
                }
                else
                {
                    mXmlWriter.WriteStartElement(DsmlConstants.ElementSearchReqFilterAnd);
                }

                foreach (object andClause in filter.Filter.And)
                {
                    WriteFilter((ADFilter)andClause, false, mXmlWriter, strNamespace);
                }
                mXmlWriter.WriteEndElement();
                break;

            case ADFilter.FilterType.Or:
                if (strNamespace != null)
                {
                    mXmlWriter.WriteStartElement(DsmlConstants.ElementSearchReqFilterOr, strNamespace);
                }
                else
                {
                    mXmlWriter.WriteStartElement(DsmlConstants.ElementSearchReqFilterOr);
                }

                foreach (object orClause in filter.Filter.Or)
                {
                    WriteFilter((ADFilter)orClause, false, mXmlWriter, strNamespace);
                }
                mXmlWriter.WriteEndElement();
                break;

            case ADFilter.FilterType.Not:
                if (strNamespace != null)
                {
                    mXmlWriter.WriteStartElement(DsmlConstants.ElementSearchReqFilterNot, strNamespace);
                }
                else
                {
                    mXmlWriter.WriteStartElement(DsmlConstants.ElementSearchReqFilterNot);
                }

                WriteFilter(filter.Filter.Not, false, mXmlWriter, strNamespace);
                mXmlWriter.WriteEndElement();
                break;

            case ADFilter.FilterType.EqualityMatch:
                WriteAttrib(DsmlConstants.ElementSearchReqFilterEqual,
                            filter.Filter.EqualityMatch, mXmlWriter, strNamespace);
                break;

            case ADFilter.FilterType.Present:
                if (strNamespace != null)
                {
                    mXmlWriter.WriteStartElement(DsmlConstants.ElementSearchReqFilterPresent, strNamespace);
                }
                else
                {
                    mXmlWriter.WriteStartElement(DsmlConstants.ElementSearchReqFilterPresent);
                }
                mXmlWriter.WriteAttributeString(DsmlConstants.AttrSearchReqFilterPresentName,
                                                filter.Filter.Present);
                mXmlWriter.WriteEndElement();
                break;

            case ADFilter.FilterType.GreaterOrEqual:
                WriteAttrib(DsmlConstants.ElementSearchReqFilterGrteq,
                            filter.Filter.GreaterOrEqual, mXmlWriter, strNamespace);
                break;

            case ADFilter.FilterType.LessOrEqual:
                WriteAttrib(DsmlConstants.ElementSearchReqFilterLesseq,
                            filter.Filter.LessOrEqual, mXmlWriter, strNamespace);
                break;

            case ADFilter.FilterType.ApproxMatch:
                WriteAttrib(DsmlConstants.ElementSearchReqFilterApprox,
                            filter.Filter.ApproxMatch, mXmlWriter, strNamespace);
                break;

            case ADFilter.FilterType.ExtensibleMatch:
                ADExtenMatchFilter exten = filter.Filter.ExtensibleMatch;

                if (strNamespace != null)
                {
                    mXmlWriter.WriteStartElement(DsmlConstants.ElementSearchReqFilterExtenmatch, strNamespace);
                }
                else
                {
                    mXmlWriter.WriteStartElement(DsmlConstants.ElementSearchReqFilterExtenmatch);
                }

                if ((exten.Name != null) && (exten.Name.Length != 0))
                {
                    mXmlWriter.WriteAttributeString(
                        DsmlConstants.AttrSearchReqFilterExtenmatchName, exten.Name);
                }

                if ((exten.MatchingRule != null) && (exten.MatchingRule.Length != 0))
                {
                    mXmlWriter.WriteAttributeString(
                        DsmlConstants.AttrSearchReqFilterExtenmatchMatchrule, exten.MatchingRule);
                }

                mXmlWriter.WriteAttributeString(
                    DsmlConstants.AttrSearchReqFilterExtenmatchDnattr,
                    XmlConvert.ToString(exten.DNAttributes));

                WriteValue(DsmlConstants.ElementSearchReqFilterExtenmatchValue, exten.Value, mXmlWriter, strNamespace);
                mXmlWriter.WriteEndElement();
                break;

            case ADFilter.FilterType.Substrings:
                //handle <substrings>
                ADSubstringFilter substr = filter.Filter.Substrings;

                if (strNamespace != null)
                {
                    mXmlWriter.WriteStartElement(DsmlConstants.ElementSearchReqFilterSubstr, strNamespace);
                }
                else
                {
                    mXmlWriter.WriteStartElement(DsmlConstants.ElementSearchReqFilterSubstr);
                }

                mXmlWriter.WriteAttributeString(DsmlConstants.AttrSearchReqFilterSubstrName,
                                                substr.Name);

                if (substr.Initial != null)
                {
                    WriteValue(DsmlConstants.ElementSearchReqFilterSubstrInit,
                               substr.Initial, mXmlWriter, strNamespace);
                }

                if (substr.Any != null)
                {
                    foreach (object sub in substr.Any)
                    {
                        WriteValue(DsmlConstants.ElementSearchReqFilterSubstrAny,
                                   (ADValue)sub, mXmlWriter, strNamespace);
                    }
                }

                if (substr.Final != null)
                {
                    WriteValue(DsmlConstants.ElementSearchReqFilterSubstrFinal,
                               substr.Final, mXmlWriter, strNamespace);
                }

                mXmlWriter.WriteEndElement();
                break;

            default:
                Debug.Fail("Invalid substring filter");

                //just in case ... this will be caught by the caller
                throw new ArgumentException(Res.GetString(Res.InvalidFilterType, filter.Type));
            }

            if (filterTags)
            {
                mXmlWriter.WriteEndElement();     //</filter>
            }
        }
Exemplo n.º 4
0
        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);
        }
Exemplo n.º 5
0
 public void WriteFilter(ADFilter filter, bool filterTags, XmlWriter mXmlWriter, string strNamespace)
 {
     if (filterTags)
     {
         if (strNamespace == null)
         {
             mXmlWriter.WriteStartElement("filter");
         }
         else
         {
             mXmlWriter.WriteStartElement("filter", strNamespace);
         }
     }
     ADFilter.FilterType type = filter.Type;
     if (type == ADFilter.FilterType.And)
     {
         if (strNamespace == null)
         {
             mXmlWriter.WriteStartElement("and");
         }
         else
         {
             mXmlWriter.WriteStartElement("and", strNamespace);
         }
         foreach (object and in filter.Filter.And)
         {
             this.WriteFilter((ADFilter)and, false, mXmlWriter, strNamespace);
         }
         mXmlWriter.WriteEndElement();
     }
     else if (type == ADFilter.FilterType.Or)
     {
         if (strNamespace == null)
         {
             mXmlWriter.WriteStartElement("or");
         }
         else
         {
             mXmlWriter.WriteStartElement("or", strNamespace);
         }
         foreach (object or in filter.Filter.Or)
         {
             this.WriteFilter((ADFilter)or, false, mXmlWriter, strNamespace);
         }
         mXmlWriter.WriteEndElement();
     }
     else if (type == ADFilter.FilterType.Not)
     {
         if (strNamespace == null)
         {
             mXmlWriter.WriteStartElement("not");
         }
         else
         {
             mXmlWriter.WriteStartElement("not", strNamespace);
         }
         this.WriteFilter(filter.Filter.Not, false, mXmlWriter, strNamespace);
         mXmlWriter.WriteEndElement();
     }
     else if (type == ADFilter.FilterType.EqualityMatch)
     {
         this.WriteAttrib("equalityMatch", filter.Filter.EqualityMatch, mXmlWriter, strNamespace);
     }
     else if (type == ADFilter.FilterType.Substrings)
     {
         ADSubstringFilter substrings = filter.Filter.Substrings;
         if (strNamespace == null)
         {
             mXmlWriter.WriteStartElement("substrings");
         }
         else
         {
             mXmlWriter.WriteStartElement("substrings", strNamespace);
         }
         mXmlWriter.WriteAttributeString("name", substrings.Name);
         if (substrings.Initial != null)
         {
             this.WriteValue("initial", substrings.Initial, mXmlWriter, strNamespace);
         }
         if (substrings.Any != null)
         {
             foreach (object any in substrings.Any)
             {
                 this.WriteValue("any", (ADValue)any, mXmlWriter, strNamespace);
             }
         }
         if (substrings.Final != null)
         {
             this.WriteValue("final", substrings.Final, mXmlWriter, strNamespace);
         }
         mXmlWriter.WriteEndElement();
     }
     else if (type == ADFilter.FilterType.GreaterOrEqual)
     {
         this.WriteAttrib("greaterOrEqual", filter.Filter.GreaterOrEqual, mXmlWriter, strNamespace);
     }
     else if (type == ADFilter.FilterType.LessOrEqual)
     {
         this.WriteAttrib("lessOrEqual", filter.Filter.LessOrEqual, mXmlWriter, strNamespace);
     }
     else if (type == ADFilter.FilterType.Present)
     {
         if (strNamespace == null)
         {
             mXmlWriter.WriteStartElement("present");
         }
         else
         {
             mXmlWriter.WriteStartElement("present", strNamespace);
         }
         mXmlWriter.WriteAttributeString("name", filter.Filter.Present);
         mXmlWriter.WriteEndElement();
     }
     else if (type == ADFilter.FilterType.ApproxMatch)
     {
         this.WriteAttrib("approxMatch", filter.Filter.ApproxMatch, mXmlWriter, strNamespace);
     }
     else if (type == ADFilter.FilterType.ExtensibleMatch)
     {
         ADExtenMatchFilter extensibleMatch = filter.Filter.ExtensibleMatch;
         if (strNamespace == null)
         {
             mXmlWriter.WriteStartElement("extensibleMatch");
         }
         else
         {
             mXmlWriter.WriteStartElement("extensibleMatch", strNamespace);
         }
         if (extensibleMatch.Name != null && extensibleMatch.Name.Length != 0)
         {
             mXmlWriter.WriteAttributeString("name", extensibleMatch.Name);
         }
         if (extensibleMatch.MatchingRule != null && extensibleMatch.MatchingRule.Length != 0)
         {
             mXmlWriter.WriteAttributeString("matchingRule", extensibleMatch.MatchingRule);
         }
         mXmlWriter.WriteAttributeString("dnAttributes", XmlConvert.ToString(extensibleMatch.DNAttributes));
         this.WriteValue("value", extensibleMatch.Value, mXmlWriter, strNamespace);
         mXmlWriter.WriteEndElement();
     }
     else
     {
         object[] objArray = new object[1];
         objArray[0] = (object)filter.Type;
         throw new ArgumentException(Res.GetString("InvalidFilterType", objArray));
     }
     if (filterTags)
     {
         mXmlWriter.WriteEndElement();
     }
 }
        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;
        }
Exemplo n.º 7
0
        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);
            }
        }
Exemplo n.º 8
0
        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);
        }
Exemplo n.º 9
0
		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;
		}