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 java.lang.Object

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

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, java.lang.String filter)
static ExprNode	parse(SchemaManager schemaManager, java.lang.String filter, Position pos)
static ExprNode	parse(java.lang.String filter) Parses a search filter from it's string representation to an expression node object.
static ExprNode	parse(java.lang.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, 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, java.lang.String attribute, byte[] filter, 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, 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, java.lang.String attribute, byte[] filter, 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, Position pos, boolean relaxed) filtercomp = and / or / not / item and = '&' filterlist or = '|' filterlist not = '!' filter item = simple / present / substring / extensible simple = attr filtertype assertionvalue present = attr EQUALS ASTERISK substring = attr EQUALS [initial] any [final] extensible = ( attr [dnattrs] [matchingrule] COLON EQUALS assertionvalue ) / ( [dnattrs] matchingrule COLON EQUALS assertionvalue )
private static ExprNode	parseFilterInternal(SchemaManager schemaManager, byte[] filter, Position pos, boolean relaxed) Pasre the grammar rule : filter ::= '(' filterComp ')'
private static ExprNode	parseItem(SchemaManager schemaManager, byte[] filter, Position pos, byte b, boolean relaxed) Parse the following grammar : item = simple / present / substring / extensible simple = attr filtertype assertionvalue filtertype = '=' / '~=' / '>=' / '<=' present = attr '=' '*' substring = attr '=' [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, java.lang.String attribute, byte[] filter, 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, java.lang.String attribute, Value<?> initial, byte[] filter, Position pos) Parse a substring

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,
                                        java.lang.String attribute,
                                        byte[] filter,
                                        Position pos,
                                        boolean relaxed)
                                 throws LdapException,
                                        java.text.ParseException

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

Throws:

LdapException

java.text.ParseException

parseAssertionValue

private static Value<?> parseAssertionValue(SchemaManager schemaManager,
                                            java.lang.String attribute,
                                            byte[] filter,
                                            Position pos)
                                     throws java.text.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

java.text.ParseException

parseAssertionValue

private static Value<?> parseAssertionValue(SchemaManager schemaManager,
                                            byte[] filter,
                                            Position pos)
                                     throws java.text.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:

java.text.ParseException

parseSubstring

private static ExprNode parseSubstring(SchemaManager schemaManager,
                                       java.lang.String attribute,
                                       Value<?> initial,
                                       byte[] filter,
                                       Position pos)
                                throws java.text.ParseException,
                                       LdapException

Parse a substring

Throws:

java.text.ParseException

LdapException

parsePresenceEqOrSubstring

private static ExprNode parsePresenceEqOrSubstring(SchemaManager schemaManager,
                                                   java.lang.String attribute,
                                                   byte[] filter,
                                                   Position pos)
                                            throws java.text.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:

java.text.ParseException

LdapException

parseItem

private static ExprNode parseItem(SchemaManager schemaManager,
                                  byte[] filter,
                                  Position pos,
                                  byte b,
                                  boolean relaxed)
                           throws java.text.ParseException,
                                  LdapException

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

Throws:

java.text.ParseException

LdapException

parseBranchNode

private static ExprNode parseBranchNode(SchemaManager schemaManager,
                                        ExprNode node,
                                        byte[] filter,
                                        Position pos,
                                        boolean relaxed)
                                 throws java.text.ParseException,
                                        LdapException

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

Returns:

Throws:

java.text.ParseException

LdapException

parseFilterComp

private static ExprNode parseFilterComp(SchemaManager schemaManager,
                                        byte[] filter,
                                        Position pos,
                                        boolean relaxed)
                                 throws java.text.ParseException,
                                        LdapException

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

Throws:

java.text.ParseException

LdapException

parseFilterInternal

private static ExprNode parseFilterInternal(SchemaManager schemaManager,
                                            byte[] filter,
                                            Position pos,
                                            boolean relaxed)
                                     throws java.text.ParseException,
                                            LdapException

Pasre the grammar rule : filter ::= '(' filterComp ')'

Throws:

java.text.ParseException

LdapException

parse

public static ExprNode parse(java.lang.String filter)
                      throws java.text.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:

java.text.ParseException

parse

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

Throws:

java.text.ParseException

See Also:

parse(String)

parse

public static ExprNode parse(SchemaManager schemaManager,
                             java.lang.String filter)
                      throws java.text.ParseException

Throws:

java.text.ParseException

See Also:

parse(String)

parse

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

Throws:

java.text.ParseException

See Also:

parse(String)

parse

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

Throws:

java.text.ParseException

parse

public static ExprNode parse(SchemaManager schemaManager,
                             java.lang.String filter,
                             Position pos)
                      throws java.text.ParseException

Throws:

java.text.ParseException

See Also:

parse(String)

parse

public static ExprNode parse(java.lang.String filter,
                             boolean relaxed)
                      throws java.text.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:

java.text.ParseException