org.apache.directory.api.ldap.model.filter

Class FilterParser

java.lang.Object

org.apache.directory.api.ldap.model.filter.FilterParser

public final class FilterParser
extends Object

This class parse a Ldap filter. The grammar is given in RFC 4515

Author:

Apache Directory Project

Constructor Summary

Constructors

Modifier	Constructor and Description
private	FilterParser()

Method Summary

Modifier and Type	Method and Description
static ExprNode	parse(byte[] filter)
static ExprNode	parse(SchemaManager schemaManager, byte[] filter)
private static ExprNode	parse(SchemaManager schemaManager, byte[] filter, boolean relaxed)
static ExprNode	parse(SchemaManager schemaManager, String filter)
static ExprNode	parse(SchemaManager schemaManager, String filter, org.apache.directory.api.util.Position pos)
static ExprNode	parse(String filter) Parses a search filter from it's string representation to an expression node object.
static ExprNode	parse(String filter, boolean relaxed) Parses a search filter from it's string representation to an expression node object.
private static Value<?>	parseAssertionValue(SchemaManager schemaManager, byte[] filter, org.apache.directory.api.util.Position pos) An assertion value : assertionvalue = valueencoding valueencoding = 0*(normal / escaped) normal = UTF1SUBSET / UTFMB escaped = '\' HEX HEX HEX = '0'-'9' / 'A'-'F' / 'a'-'f' UTF1SUBSET = %x01-27 / %x2B-5B / %x5D-7F (Everything but '\0', '*', '(', ')' and '\') UTFMB = UTF2 / UTF3 / UTF4 UTF0 = %x80-BF UTF2 = %xC2-DF UTF0 UTF3 = %xE0 %xA0-BF UTF0 / %xE1-EC UTF0 UTF0 / %xED %x80-9F UTF0 / %xEE-EF UTF0 UTF0 UTF4 = %xF0 %x90-BF UTF0 UTF0 / %xF1-F3 UTF0 UTF0 UTF0 / %xF4 %x80-8F UTF0 UTF0 With the specific constraints (RFC 4515): "The rule ensures that the entire filter string is a" "valid UTF-8 string and provides that the octets that represent the" "ASCII characters "*" (ASCII 0x2a), "(" (ASCII 0x28), ")" (ASCII" "0x29), "\" (ASCII 0x5c), and NUL (ASCII 0x00) are represented as a" "backslash "\" (ASCII 0x5c) followed by the two hexadecimal digits" "representing the value of the encoded octet." The incoming String is already transformed from UTF-8 to unicode, so we must assume that the grammar we have to check is the following : assertionvalue = valueencoding valueencoding = 0*(normal / escaped) normal = unicodeSubset escaped = '\' HEX HEX HEX = '0'-'9' / 'A'-'F' / 'a'-'f' unicodeSubset = %x01-27 / %x2B-5B / %x5D-FFFF
private static Value<?>	parseAssertionValue(SchemaManager schemaManager, String attribute, byte[] filter, org.apache.directory.api.util.Position pos) An assertion value : assertionvalue = valueencoding valueencoding = 0*(normal / escaped) normal = UTF1SUBSET / UTFMB escaped = '\' HEX HEX HEX = '0'-'9' / 'A'-'F' / 'a'-'f' UTF1SUBSET = %x01-27 / %x2B-5B / %x5D-7F (Everything but '\0', '*', '(', ')' and '\') UTFMB = UTF2 / UTF3 / UTF4 UTF0 = %x80-BF UTF2 = %xC2-DF UTF0 UTF3 = %xE0 %xA0-BF UTF0 / %xE1-EC UTF0 UTF0 / %xED %x80-9F UTF0 / %xEE-EF UTF0 UTF0 UTF4 = %xF0 %x90-BF UTF0 UTF0 / %xF1-F3 UTF0 UTF0 UTF0 / %xF4 %x80-8F UTF0 UTF0 With the specific constraints (RFC 4515): "The rule ensures that the entire filter string is a" "valid UTF-8 string and provides that the octets that represent the" "ASCII characters "*" (ASCII 0x2a), "(" (ASCII 0x28), ")" (ASCII" "0x29), "\" (ASCII 0x5c), and NUL (ASCII 0x00) are represented as a" "backslash "\" (ASCII 0x5c) followed by the two hexadecimal digits" "representing the value of the encoded octet." The incoming String is already transformed from UTF-8 to unicode, so we must assume that the grammar we have to check is the following : assertionvalue = valueencoding valueencoding = 0*(normal / escaped) normal = unicodeSubset escaped = '\' HEX HEX HEX = '0'-'9' / 'A'-'F' / 'a'-'f' unicodeSubset = %x01-27 / %x2B-5B / %x5D-FFFF
private static ExprNode	parseBranchNode(SchemaManager schemaManager, ExprNode node, byte[] filter, org.apache.directory.api.util.Position pos, boolean relaxed) Parse AND, OR and NOT nodes : and = '&' filterlist or = '|' filterlist not = '!' filter filterlist = 1*filter
private static ExprNode	parseExtensible(SchemaManager schemaManager, String attribute, byte[] filter, org.apache.directory.api.util.Position pos, boolean relaxed) Parse an extensible extensible = ( attr [":dn"] [':' oid] ":=" assertionvalue ) / ( [":dn"] ':' oid ":=" assertionvalue ) matchingrule = ":" oid
private static ExprNode	parseFilterComp(SchemaManager schemaManager, byte[] filter, org.apache.directory.api.util.Position pos, boolean relaxed) filtercomp = and / or / not / item and = '&' WSP* filterlist or = '|' WSP* filterlist not = '!' WSP* filter item = simple / present / substring / extensible simple = attr WSP* filtertype WSP* assertionvalue present = attr WSP* EQUALS ASTERISK substring = attr WSP* EQUALS WSP* [initial] any [final] extensible = ( attr [dnattrs] [matchingrule] COLON EQUALS assertionvalue ) / ( [dnattrs] matchingrule COLON EQUALS assertionvalue )
private static ExprNode	parseFilterInternal(SchemaManager schemaManager, byte[] filter, org.apache.directory.api.util.Position pos, boolean relaxed) Parse the grammar rule : filter ::= WSP* '(' WSP* filterComp WSP* ')' WSP*
private static ExprNode	parseItem(SchemaManager schemaManager, byte[] filter, org.apache.directory.api.util.Position pos, byte b, boolean relaxed) Parse the following grammar : item = simple / present / substring / extensible simple = attr WSP* filtertype assertionvalue filtertype = '=' / '~=' / '>=' / '<=' present = attr WSP* '=' '*' substring = attr WSP* '=' [initial] any [final] extensible = ( attr [":dn"] [':' oid] ":=" assertionvalue ) / ( [":dn"] ':' oid ":=" assertionvalue ) matchingrule = ":" oid An item starts with an attribute or a colon.
private static ExprNode	parsePresenceEqOrSubstring(SchemaManager schemaManager, String attribute, byte[] filter, org.apache.directory.api.util.Position pos) Here is the grammar to parse : simple ::= '=' assertionValue present ::= '=' '*' substring ::= '=' [initial] any [final] initial ::= assertionValue any ::= '*' ( assertionValue '*')* As we can see, there is an ambiguity in the grammar : attr=* can be seen as a present or as a substring.
private static ExprNode	parseSubstring(SchemaManager schemaManager, String attribute, Value<?> initial, byte[] filter, org.apache.directory.api.util.Position pos) Parse a substring
private static void	skipWhiteSpaces(byte[] filter, org.apache.directory.api.util.Position pos) Skip teh white spaces (0x20, 0x09, 0x0a and 0x0d)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

FilterParser

private FilterParser()

Method Detail

parseExtensible

private static ExprNode parseExtensible(SchemaManager schemaManager,
                                        String attribute,
                                        byte[] filter,
                                        org.apache.directory.api.util.Position pos,
                                        boolean relaxed)
                                 throws LdapException,
                                        ParseException

Parse an extensible extensible = ( attr [":dn"] [':' oid] ":=" assertionvalue ) / ( [":dn"] ':' oid ":=" assertionvalue ) matchingrule = ":" oid

Throws:

LdapException

ParseException

parseAssertionValue

private static Value<?> parseAssertionValue(SchemaManager schemaManager,
                                            String attribute,
                                            byte[] filter,
                                            org.apache.directory.api.util.Position pos)
                                     throws ParseException

An assertion value : assertionvalue = valueencoding valueencoding = 0*(normal / escaped) normal = UTF1SUBSET / UTFMB escaped = '\' HEX HEX HEX = '0'-'9' / 'A'-'F' / 'a'-'f' UTF1SUBSET = %x01-27 / %x2B-5B / %x5D-7F (Everything but '\0', '*', '(', ')' and '\') UTFMB = UTF2 / UTF3 / UTF4 UTF0 = %x80-BF UTF2 = %xC2-DF UTF0 UTF3 = %xE0 %xA0-BF UTF0 / %xE1-EC UTF0 UTF0 / %xED %x80-9F UTF0 / %xEE-EF UTF0 UTF0 UTF4 = %xF0 %x90-BF UTF0 UTF0 / %xF1-F3 UTF0 UTF0 UTF0 / %xF4 %x80-8F UTF0 UTF0 With the specific constraints (RFC 4515): "The rule ensures that the entire filter string is a" "valid UTF-8 string and provides that the octets that represent the" "ASCII characters "*" (ASCII 0x2a), "(" (ASCII 0x28), ")" (ASCII" "0x29), "\" (ASCII 0x5c), and NUL (ASCII 0x00) are represented as a" "backslash "\" (ASCII 0x5c) followed by the two hexadecimal digits" "representing the value of the encoded octet." The incoming String is already transformed from UTF-8 to unicode, so we must assume that the grammar we have to check is the following : assertionvalue = valueencoding valueencoding = 0*(normal / escaped) normal = unicodeSubset escaped = '\' HEX HEX HEX = '0'-'9' / 'A'-'F' / 'a'-'f' unicodeSubset = %x01-27 / %x2B-5B / %x5D-FFFF

Throws:

LdapInvalidAttributeValueException

ParseException

parseAssertionValue

private static Value<?> parseAssertionValue(SchemaManager schemaManager,
                                            byte[] filter,
                                            org.apache.directory.api.util.Position pos)
                                     throws ParseException

An assertion value : assertionvalue = valueencoding valueencoding = 0*(normal / escaped) normal = UTF1SUBSET / UTFMB escaped = '\' HEX HEX HEX = '0'-'9' / 'A'-'F' / 'a'-'f' UTF1SUBSET = %x01-27 / %x2B-5B / %x5D-7F (Everything but '\0', '*', '(', ')' and '\') UTFMB = UTF2 / UTF3 / UTF4 UTF0 = %x80-BF UTF2 = %xC2-DF UTF0 UTF3 = %xE0 %xA0-BF UTF0 / %xE1-EC UTF0 UTF0 / %xED %x80-9F UTF0 / %xEE-EF UTF0 UTF0 UTF4 = %xF0 %x90-BF UTF0 UTF0 / %xF1-F3 UTF0 UTF0 UTF0 / %xF4 %x80-8F UTF0 UTF0 With the specific constraints (RFC 4515): "The rule ensures that the entire filter string is a" "valid UTF-8 string and provides that the octets that represent the" "ASCII characters "*" (ASCII 0x2a), "(" (ASCII 0x28), ")" (ASCII" "0x29), "\" (ASCII 0x5c), and NUL (ASCII 0x00) are represented as a" "backslash "\" (ASCII 0x5c) followed by the two hexadecimal digits" "representing the value of the encoded octet." The incoming String is already transformed from UTF-8 to unicode, so we must assume that the grammar we have to check is the following : assertionvalue = valueencoding valueencoding = 0*(normal / escaped) normal = unicodeSubset escaped = '\' HEX HEX HEX = '0'-'9' / 'A'-'F' / 'a'-'f' unicodeSubset = %x01-27 / %x2B-5B / %x5D-FFFF

Throws:

ParseException

parseSubstring

private static ExprNode parseSubstring(SchemaManager schemaManager,
                                       String attribute,
                                       Value<?> initial,
                                       byte[] filter,
                                       org.apache.directory.api.util.Position pos)
                                throws ParseException,
                                       LdapException

Parse a substring

Throws:

ParseException

LdapException

parsePresenceEqOrSubstring

private static ExprNode parsePresenceEqOrSubstring(SchemaManager schemaManager,
                                                   String attribute,
                                                   byte[] filter,
                                                   org.apache.directory.api.util.Position pos)
                                            throws ParseException,
                                                   LdapException

Here is the grammar to parse : simple ::= '=' assertionValue present ::= '=' '*' substring ::= '=' [initial] any [final] initial ::= assertionValue any ::= '*' ( assertionValue '*')* As we can see, there is an ambiguity in the grammar : attr=* can be seen as a present or as a substring. As stated in the RFC : "Note that although both the and productions in" "the grammar above can produce the "attr=*" construct, this construct" "is used only to denote a presence filter." (RFC 4515, 3) We have also to consider the difference between a substring and the equality node : this last node does not contain a '*'

Parameters:

attributeType -

filter -

pos -

Returns:

Throws:

ParseException

LdapException

parseItem

private static ExprNode parseItem(SchemaManager schemaManager,
                                  byte[] filter,
                                  org.apache.directory.api.util.Position pos,
                                  byte b,
                                  boolean relaxed)
                           throws ParseException,
                                  LdapException

Parse the following grammar : item = simple / present / substring / extensible simple = attr WSP* filtertype assertionvalue filtertype = '=' / '~=' / '>=' / '<=' present = attr WSP* '=' '*' substring = attr WSP* '=' [initial] any [final] extensible = ( attr [":dn"] [':' oid] ":=" assertionvalue ) / ( [":dn"] ':' oid ":=" assertionvalue ) matchingrule = ":" oid An item starts with an attribute or a colon.

Throws:

ParseException

LdapException

parseBranchNode

private static ExprNode parseBranchNode(SchemaManager schemaManager,
                                        ExprNode node,
                                        byte[] filter,
                                        org.apache.directory.api.util.Position pos,
                                        boolean relaxed)
                                 throws ParseException,
                                        LdapException

Parse AND, OR and NOT nodes : and = '&' filterlist or = '|' filterlist not = '!' filter filterlist = 1*filter

Returns:

Throws:

ParseException

LdapException

parseFilterComp

private static ExprNode parseFilterComp(SchemaManager schemaManager,
                                        byte[] filter,
                                        org.apache.directory.api.util.Position pos,
                                        boolean relaxed)
                                 throws ParseException,
                                        LdapException

filtercomp = and / or / not / item and = '&' WSP* filterlist or = '|' WSP* filterlist not = '!' WSP* filter item = simple / present / substring / extensible simple = attr WSP* filtertype WSP* assertionvalue present = attr WSP* EQUALS ASTERISK substring = attr WSP* EQUALS WSP* [initial] any [final] extensible = ( attr [dnattrs] [matchingrule] COLON EQUALS assertionvalue ) / ( [dnattrs] matchingrule COLON EQUALS assertionvalue )

Throws:

ParseException

LdapException

skipWhiteSpaces

private static void skipWhiteSpaces(byte[] filter,
                                    org.apache.directory.api.util.Position pos)

Skip teh white spaces (0x20, 0x09, 0x0a and 0x0d)

Parameters:

filter -

pos -

parseFilterInternal

private static ExprNode parseFilterInternal(SchemaManager schemaManager,
                                            byte[] filter,
                                            org.apache.directory.api.util.Position pos,
                                            boolean relaxed)
                                     throws ParseException,
                                            LdapException

Parse the grammar rule : filter ::= WSP* '(' WSP* filterComp WSP* ')' WSP*

Throws:

ParseException

LdapException

parse

public static ExprNode parse(String filter)
                      throws ParseException

Parses a search filter from it's string representation to an expression node object.

Parameters:

filter - the search filter in it's string representation

Returns:

the expression node object

Throws:

ParseException - If the filter is invalid

parse

public static ExprNode parse(byte[] filter)
                      throws ParseException

Parameters:

filter - the search filter in it's string representation

Returns:

the expression node object

Throws:

ParseException - If the filter is invalid

See Also:

parse(String)

parse

public static ExprNode parse(SchemaManager schemaManager,
                             String filter)
                      throws ParseException

Parameters:

schemaManager - The SchemaManager

filter - the search filter in it's string representation

Returns:

the expression node object

Throws:

ParseException - If the filter is invalid

See Also:

parse(String)

parse

public static ExprNode parse(SchemaManager schemaManager,
                             byte[] filter)
                      throws ParseException

Parameters:

schemaManager - The SchemaManager

filter - the search filter in it's string representation

Returns:

the expression node object

Throws:

ParseException - If the filter is invalid

See Also:

parse(String)

parse

private static ExprNode parse(SchemaManager schemaManager,
                              byte[] filter,
                              boolean relaxed)
                       throws ParseException

Throws:

ParseException

parse

public static ExprNode parse(SchemaManager schemaManager,
                             String filter,
                             org.apache.directory.api.util.Position pos)
                      throws ParseException

Parameters:

schemaManager - The SchemaManager

filter - the search filter in it's string representation

pos - The position in the filter

Returns:

the expression node object

Throws:

ParseException - If the filter is invalid

See Also:

parse(String)

parse

public static ExprNode parse(String filter,
                             boolean relaxed)
                      throws ParseException

Parses a search filter from it's string representation to an expression node object. In relaxed mode the filter may violate RFC 4515, e.g. the underscore in attribute names is allowed.

Parameters:

filter - the search filter in it's string representation

relaxed - true to parse the filter in relaxed mode

Returns:

the expression node object

Throws:

ParseException - If the filter is invalid