RFC 1558 INFORMATIONAL LDAP · DIRECTORIES

LDAP filters: A String Representation of LDAP Search Filters

A readable string syntax for expressing LDAP search filters.

On rfc-editor.org ↗
PUBLISHED
December 1993
AUTHORS
T. Howes
STREAM
Legacy
OBSOLETED BY
RFC 1960 — LDAP Search Filters
AND OPERATOR
&
OR OPERATOR
|
NOT OPERATOR
!
ESCAPE CHARACTER
\
DOI
10.17487/RFC1558

RFC text

Contents
Original text · RFC Editor View on rfc-editor.org ↗
Network Working Group                                           T. Howes
Request for Comments: 1558                        University of Michigan
Category: Informational                                    December 1993


             A String Representation of LDAP Search Filters

Status of this Memo

   This memo provides information for the Internet community.  This memo
   does not specify an Internet standard of any kind.  Distribution of
   this memo is unlimited.

Abstract

   The Lightweight Directory Access Protocol (LDAP) [1] defines a
   network representation of a search filter transmitted to an LDAP
   server.  Some applications may find it useful to have a common way of
   representing these search filters in a human-readable form.  This
   document defines a human-readable string format for representing LDAP
   search filters.

1.  LDAP Search Filter Definition

   An LDAP search filter is defined in [1] as follows:

     Filter ::= CHOICE {
             and                [0] SET OF Filter,
             or                 [1] SET OF Filter,
             not                [2] Filter,
             equalityMatch      [3] AttributeValueAssertion,
             substrings         [4] SubstringFilter,
             greaterOrEqual     [5] AttributeValueAssertion,
             lessOrEqual        [6] AttributeValueAssertion,
             present            [7] AttributeType,
             approxMatch        [8] AttributeValueAssertion
     }

     SubstringFilter ::= SEQUENCE {
             type    AttributeType,
             SEQUENCE OF CHOICE {
                     initial        [0] LDAPString,
                     any            [1] LDAPString,
                     final          [2] LDAPString
             }
     }
     AttributeValueAssertion ::= SEQUENCE
             attributeType   AttributeType,
             attributeValue  AttributeValue
     }

     AttributeType ::= LDAPString

     AttributeValue ::= OCTET STRING

     LDAPString ::= OCTET STRING

   where the LDAPString above is limited to the IA5 character set.  The
   AttributeType is a string representation of the attribute object
   identifier in dotted OID format (e.g., "2.5.4.10"), or the shorter
   string name of the attribute (e.g., "organizationName", or "o").  The
   AttributeValue OCTET STRING has the form defined in [2].  The Filter
   is encoded for transmission over a network using the Basic Encoding
   Rules defined in [3], with simplifications described in [1].

2.  String Search Filter Definition

   The string representation of an LDAP search filter is defined by the
   following BNF.  It uses a prefix format.

     <filter> ::= '(' <filtercomp> ')'
     <filtercomp> ::= <and> | <or> | <not> | <item>
     <and> ::= '&' <filterlist>
     <or> ::= '|' <filterlist>
     <not> ::= '!' <filter>
     <filterlist> ::= <filter> | <filter> <filterlist>
     <item> ::= <simple> | <present> | <substring>
     <simple> ::= <attr> <filtertype> <value>
     <filtertype> ::= <equal> | <approx> | <greater> | <less>
     <equal> ::= '='
     <approx> ::= '~='
     <greater> ::= '>='
     <less> ::= '<='
     <present> ::= <attr> '=*'
     <substring> ::= <attr> '=' <initial> <any> <final>
     <initial> ::= NULL | <value>
     <any> ::= '*' <starval>
     <starval> ::= NULL | <value> '*' <starval>
     <final> ::= NULL | <value>

   <attr> is a string representing an AttributeType, and has the format
   defined in [1].  <value> is a string representing an AttributeValue,
   or part of one, and has the form defined in [2].  If a <value> must
   contain one of the characters '*' or '(' or ')', these characters
   should be escaped by preceding them with the backslash '\' character.

3.  Examples

   This section gives a few examples of search filters written using
   this notation.

     (cn=Babs Jensen)
     (!(cn=Tim Howes))
     (&(objectClass=Person)(|(sn=Jensen)(cn=Babs J*)))
     (o=univ*of*mich*)

4.  Security Considerations

   Security issues are not discussed in this memo.

5.  References

   [1] Yeong, W., Howes, T., and S. Kille, "Lightweight Directory Access
       Protocol", RFC 1487, Performance Systems International,
       University of Michigan, ISODE Consortium, July 1993.

   [2] Howes, T., Kille, S., Yeong, W., and C. Robbins, "The String
       Representation of Standard Attribute Syntaxes", RFC 1488,
       University of Michigan, ISODE Consortium, Performance Systems
       International, NeXor Ltd., July 1993.

   [3] "Specification of Basic Encoding Rules for Abstract Syntax
       Notation One (ASN.1)", CCITT Recommendation X.209, 1988.

6.  Author's Address

       Tim Howes
       University of Michigan
       ITD Research Systems
       535 W William St.
       Ann Arbor, MI 48103-4943
       USA

       Phone: +1 313 747-4454
       EMail: tim@umich.edu

ISO Plain Language

On this page
PROBLEMLDAP search filters are encoded for network transmission, but applications may need a human-readable way to represent them.
MECHANISMThe memo defines a parenthesized prefix syntax with logical operators, attribute comparisons, presence tests, and substring matching.
STATUS TODAYRFC 1558 is Informational and was obsoleted by RFC 1960.

§1From Network Encoding to Text

LDAP defines a network representation of search filters. RFC 1558 provides a human-readable string format for applications that need a common text representation. The format uses prefix notation, placing a logical operator before its filters.

The network form of an LDAP search filter is not easy to read. This memo defines a text form that people and applications can use to express the same kind of search.

§2Operators and Comparisons

A filter is enclosed in parentheses. The logical operators are & for AND, | for OR, and ! for NOT. Simple comparisons use =, ~=, >=, or <=. The =* form tests whether an attribute is present. Substring filters use the asterisk as a wildcard, and an asterisk or parenthesis in a value is escaped with a backslash.

Put each filter in parentheses. Use ampersand for AND, a vertical bar for OR, and an exclamation mark for NOT; comparisons test an attribute against a value.

§3Example Filter Strings

(cn=Babs Jensen) tests for a common name equal to Babs Jensen. (!(cn=Tim Howes)) negates that equality test. (&(objectClass=Person)(|(sn=Jensen)(cn=Babs J*))) combines an AND with an OR. (o=univ*of*mich*) uses substring wildcards in an organization value.

The memo says security issues are not discussed.

Filters can combine conditions, negate a condition, or match part of an attribute value. The parentheses make the structure visible in the text.

EXAMPLES FROM THE RFC
LDAP search filter strings
(cn=Babs Jensen)
(!(cn=Tim Howes))
(&(objectClass=Person)(|(sn=Jensen)(cn=Babs J*)))
(o=univ*of*mich*)

§4References