4 Copyright (C) Andrew Tridgell 2004
6 ** NOTE! The following LGPL license applies to the ldb
7 ** library. This does NOT imply that all of Samba is released
10 This library is free software; you can redistribute it and/or
11 modify it under the terms of the GNU Lesser General Public
12 License as published by the Free Software Foundation; either
13 version 3 of the License, or (at your option) any later version.
15 This library is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 Lesser General Public License for more details.
20 You should have received a copy of the GNU Lesser General Public
21 License along with this library; if not, see <http://www.gnu.org/licenses/>.
27 * Component: ldb expression parsing
29 * Description: parse LDAP-like search expressions
31 * Author: Andrew Tridgell
36 - add RFC2254 binary string handling
37 - possibly add ~=, <= and >= handling
38 - expand the test suite
39 - add better parse error handling
44 #include "ldb/include/includes.h"
45 #include "system/locale.h"
47 struct ldb_val ldb_binary_decode(void *mem_ctx, const char *str);
50 a filter is defined by:
51 <filter> ::= '(' <filtercomp> ')'
52 <filtercomp> ::= <and> | <or> | <not> | <simple>
53 <and> ::= '&' <filterlist>
54 <or> ::= '|' <filterlist>
55 <not> ::= '!' <filter>
56 <filterlist> ::= <filter> | <filter> <filterlist>
57 <simple> ::= <attributetype> <filtertype> <attributevalue>
58 <filtertype> ::= '=' | '~=' | '<=' | '>='
62 decode a RFC2254 binary string representation of a buffer.
65 struct ldb_val ldb_binary_decode(void *mem_ctx, const char *str)
69 int slen = str?strlen(str):0;
71 ret.data = (uint8_t *)talloc_size(mem_ctx, slen+1);
73 if (ret.data == NULL) return ret;
75 for (i=j=0;i<slen;i++) {
78 if (sscanf(&str[i+1], "%02X", &c) != 1) {
79 talloc_free(ret.data);
80 memset(&ret, 0, sizeof(ret));
83 ((uint8_t *)ret.data)[j++] = c;
86 ((uint8_t *)ret.data)[j++] = str[i];
90 ((uint8_t *)ret.data)[j] = 0;
95 static bool need_encode(unsigned char cval)
97 if (cval < 0x20 || cval > 0x7E || strchr(" *()\\&|!\"", cval)) {
104 encode a blob as a RFC2254 binary string, escaping any
105 non-printable or '\' characters
107 char *ldb_binary_encode(void *mem_ctx, struct ldb_val val)
111 int len = val.length;
112 unsigned char *buf = val.data;
114 for (i=0;i<val.length;i++) {
115 if (need_encode(buf[i])) {
119 ret = talloc_array(mem_ctx, char, len+1);
120 if (ret == NULL) return NULL;
123 for (i=0;i<val.length;i++) {
124 if (need_encode(buf[i])) {
125 snprintf(ret+len, 4, "\\%02X", buf[i]);
138 encode a string as a RFC2254 binary string, escaping any
139 non-printable or '\' characters. This routine is suitable for use
140 in escaping user data in ldap filters.
142 char *ldb_binary_encode_string(void *mem_ctx, const char *string)
145 val.data = discard_const_p(uint8_t, string);
146 val.length = strlen(string);
147 return ldb_binary_encode(mem_ctx, val);
150 /* find the first matching wildcard */
151 static char *ldb_parse_find_wildcard(char *value)
154 value = strpbrk(value, "\\*");
155 if (value == NULL) return NULL;
157 if (value[0] == '\\') {
158 if (value[1] == '\0') return NULL;
163 if (value[0] == '*') return value;
169 /* return a NULL terminated list of binary strings representing the value
170 chunks separated by wildcards that makes the value portion of the filter
172 static struct ldb_val **ldb_wildcard_decode(void *mem_ctx, const char *string)
174 struct ldb_val **ret = NULL;
178 wc = talloc_strdup(mem_ctx, string);
179 if (wc == NULL) return NULL;
183 wc = ldb_parse_find_wildcard(str);
193 ret = talloc_realloc(mem_ctx, ret, struct ldb_val *, val + 2);
194 if (ret == NULL) return NULL;
196 ret[val] = talloc(mem_ctx, struct ldb_val);
197 if (ret[val] == NULL) return NULL;
199 *(ret[val]) = ldb_binary_decode(mem_ctx, str);
200 if ((ret[val])->data == NULL) return NULL;
212 static struct ldb_parse_tree *ldb_parse_filter(void *mem_ctx, const char **s);
216 parse an extended match
224 the ':dn' part sets the dnAttributes boolean if present
225 the oid sets the rule_id string
228 static struct ldb_parse_tree *ldb_parse_extended(struct ldb_parse_tree *ret,
229 char *attr, char *value)
233 ret->operation = LDB_OP_EXTENDED;
234 ret->u.extended.value = ldb_binary_decode(ret, value);
235 if (ret->u.extended.value.data == NULL) goto failed;
237 p1 = strchr(attr, ':');
238 if (p1 == NULL) goto failed;
239 p2 = strchr(p1+1, ':');
244 ret->u.extended.attr = attr;
245 if (strcmp(p1+1, "dn") == 0) {
246 ret->u.extended.dnAttributes = 1;
248 ret->u.extended.rule_id = talloc_strdup(ret, p2+1);
249 if (ret->u.extended.rule_id == NULL) goto failed;
251 ret->u.extended.rule_id = NULL;
254 ret->u.extended.dnAttributes = 0;
255 ret->u.extended.rule_id = talloc_strdup(ret, p1+1);
256 if (ret->u.extended.rule_id == NULL) goto failed;
266 static enum ldb_parse_op ldb_parse_filtertype(void *mem_ctx, char **type, char **value, const char **s)
268 enum ldb_parse_op filter = 0;
269 char *name, *val, *k;
273 /* retrieve attributetype name */
276 while ((isascii(*p) && isalnum((unsigned char)*p)) || (*p == '-')) { /* attribute names can only be alphanums */
280 if (*p == ':') { /* but extended searches have : and . chars too */
282 if (p == NULL) { /* malformed attribute name */
289 while (isspace((unsigned char)*p)) p++;
291 if (!strchr("=<>~:", *p)) {
296 name = (char *)talloc_memdup(mem_ctx, t, t1 - t + 1);
297 if (name == NULL) return 0;
300 /* retrieve filtertype */
303 filter = LDB_OP_EQUALITY;
304 } else if (*(p + 1) == '=') {
307 filter = LDB_OP_LESS;
311 filter = LDB_OP_GREATER;
315 filter = LDB_OP_APPROX;
319 filter = LDB_OP_EXTENDED;
330 while (isspace((unsigned char)*p)) p++;
335 while (*p && ((*p != ')') || ((*p == ')') && (*(p - 1) == '\\')))) p++;
337 val = (char *)talloc_memdup(mem_ctx, t, p - t + 1);
346 /* remove trailing spaces from value */
347 while ((k > val) && (isspace((unsigned char)*(k - 1)))) k--;
357 <simple> ::= <attributetype> <filtertype> <attributevalue>
359 static struct ldb_parse_tree *ldb_parse_simple(void *mem_ctx, const char **s)
362 struct ldb_parse_tree *ret;
363 enum ldb_parse_op filtertype;
365 ret = talloc(mem_ctx, struct ldb_parse_tree);
371 filtertype = ldb_parse_filtertype(ret, &attr, &value, s);
377 switch (filtertype) {
380 ret->operation = LDB_OP_PRESENT;
381 ret->u.present.attr = attr;
384 case LDB_OP_EQUALITY:
386 if (strcmp(value, "*") == 0) {
387 ret->operation = LDB_OP_PRESENT;
388 ret->u.present.attr = attr;
392 if (ldb_parse_find_wildcard(value) != NULL) {
393 ret->operation = LDB_OP_SUBSTRING;
394 ret->u.substring.attr = attr;
395 ret->u.substring.start_with_wildcard = 0;
396 ret->u.substring.end_with_wildcard = 0;
397 ret->u.substring.chunks = ldb_wildcard_decode(ret, value);
398 if (ret->u.substring.chunks == NULL){
403 ret->u.substring.start_with_wildcard = 1;
404 if (value[strlen(value) - 1] == '*')
405 ret->u.substring.end_with_wildcard = 1;
411 ret->operation = LDB_OP_EQUALITY;
412 ret->u.equality.attr = attr;
413 ret->u.equality.value = ldb_binary_decode(ret, value);
414 if (ret->u.equality.value.data == NULL) {
422 ret->operation = LDB_OP_GREATER;
423 ret->u.comparison.attr = attr;
424 ret->u.comparison.value = ldb_binary_decode(ret, value);
425 if (ret->u.comparison.value.data == NULL) {
433 ret->operation = LDB_OP_LESS;
434 ret->u.comparison.attr = attr;
435 ret->u.comparison.value = ldb_binary_decode(ret, value);
436 if (ret->u.comparison.value.data == NULL) {
444 ret->operation = LDB_OP_APPROX;
445 ret->u.comparison.attr = attr;
446 ret->u.comparison.value = ldb_binary_decode(ret, value);
447 if (ret->u.comparison.value.data == NULL) {
454 case LDB_OP_EXTENDED:
456 ret = ldb_parse_extended(ret, attr, value);
470 <and> ::= '&' <filterlist>
471 <or> ::= '|' <filterlist>
472 <filterlist> ::= <filter> | <filter> <filterlist>
474 static struct ldb_parse_tree *ldb_parse_filterlist(void *mem_ctx, const char **s)
476 struct ldb_parse_tree *ret, *next;
477 enum ldb_parse_op op;
492 while (isspace((unsigned char)*p)) p++;
494 ret = talloc(mem_ctx, struct ldb_parse_tree);
501 ret->u.list.num_elements = 1;
502 ret->u.list.elements = talloc(ret, struct ldb_parse_tree *);
503 if (!ret->u.list.elements) {
509 ret->u.list.elements[0] = ldb_parse_filter(ret->u.list.elements, &p);
510 if (!ret->u.list.elements[0]) {
515 while (isspace((unsigned char)*p)) p++;
517 while (*p && (next = ldb_parse_filter(ret->u.list.elements, &p))) {
518 struct ldb_parse_tree **e;
519 e = talloc_realloc(ret, ret->u.list.elements,
520 struct ldb_parse_tree *,
521 ret->u.list.num_elements + 1);
527 ret->u.list.elements = e;
528 ret->u.list.elements[ret->u.list.num_elements] = next;
529 ret->u.list.num_elements++;
530 while (isspace((unsigned char)*p)) p++;
540 <not> ::= '!' <filter>
542 static struct ldb_parse_tree *ldb_parse_not(void *mem_ctx, const char **s)
544 struct ldb_parse_tree *ret;
552 ret = talloc(mem_ctx, struct ldb_parse_tree);
558 ret->operation = LDB_OP_NOT;
559 ret->u.isnot.child = ldb_parse_filter(ret, &p);
560 if (!ret->u.isnot.child) {
572 <filtercomp> ::= <and> | <or> | <not> | <simple>
574 static struct ldb_parse_tree *ldb_parse_filtercomp(void *mem_ctx, const char **s)
576 struct ldb_parse_tree *ret;
579 while (isspace((unsigned char)*p)) p++;
583 ret = ldb_parse_filterlist(mem_ctx, &p);
587 ret = ldb_parse_filterlist(mem_ctx, &p);
591 ret = ldb_parse_not(mem_ctx, &p);
599 ret = ldb_parse_simple(mem_ctx, &p);
609 <filter> ::= '(' <filtercomp> ')'
611 static struct ldb_parse_tree *ldb_parse_filter(void *mem_ctx, const char **s)
613 struct ldb_parse_tree *ret;
621 ret = ldb_parse_filtercomp(mem_ctx, &p);
628 while (isspace((unsigned char)*p)) {
639 main parser entry point. Takes a search string and returns a parse tree
641 expression ::= <simple> | <filter>
643 struct ldb_parse_tree *ldb_parse_tree(void *mem_ctx, const char *s)
645 if (s == NULL || *s == 0) {
646 s = "(|(objectClass=*)(distinguishedName=*))";
649 while (isspace((unsigned char)*s)) s++;
652 return ldb_parse_filter(mem_ctx, &s);
655 return ldb_parse_simple(mem_ctx, &s);
660 construct a ldap parse filter given a parse tree
662 char *ldb_filter_from_tree(void *mem_ctx, struct ldb_parse_tree *tree)
671 switch (tree->operation) {
674 ret = talloc_asprintf(mem_ctx, "(%c", tree->operation==LDB_OP_AND?'&':'|');
675 if (ret == NULL) return NULL;
676 for (i=0;i<tree->u.list.num_elements;i++) {
677 s = ldb_filter_from_tree(mem_ctx, tree->u.list.elements[i]);
682 s2 = talloc_asprintf_append(ret, "%s", s);
690 s = talloc_asprintf_append(ret, ")");
697 s = ldb_filter_from_tree(mem_ctx, tree->u.isnot.child);
698 if (s == NULL) return NULL;
700 ret = talloc_asprintf(mem_ctx, "(!%s)", s);
703 case LDB_OP_EQUALITY:
704 s = ldb_binary_encode(mem_ctx, tree->u.equality.value);
705 if (s == NULL) return NULL;
706 ret = talloc_asprintf(mem_ctx, "(%s=%s)",
707 tree->u.equality.attr, s);
710 case LDB_OP_SUBSTRING:
711 ret = talloc_asprintf(mem_ctx, "(%s=%s", tree->u.substring.attr,
712 tree->u.substring.start_with_wildcard?"*":"");
713 if (ret == NULL) return NULL;
714 for (i = 0; tree->u.substring.chunks[i]; i++) {
715 s2 = ldb_binary_encode(mem_ctx, *(tree->u.substring.chunks[i]));
720 if (tree->u.substring.chunks[i+1] ||
721 tree->u.substring.end_with_wildcard) {
722 s = talloc_asprintf_append(ret, "%s*", s2);
724 s = talloc_asprintf_append(ret, "%s", s2);
732 s = talloc_asprintf_append(ret, ")");
740 s = ldb_binary_encode(mem_ctx, tree->u.equality.value);
741 if (s == NULL) return NULL;
742 ret = talloc_asprintf(mem_ctx, "(%s>=%s)",
743 tree->u.equality.attr, s);
747 s = ldb_binary_encode(mem_ctx, tree->u.equality.value);
748 if (s == NULL) return NULL;
749 ret = talloc_asprintf(mem_ctx, "(%s<=%s)",
750 tree->u.equality.attr, s);
754 ret = talloc_asprintf(mem_ctx, "(%s=*)", tree->u.present.attr);
757 s = ldb_binary_encode(mem_ctx, tree->u.equality.value);
758 if (s == NULL) return NULL;
759 ret = talloc_asprintf(mem_ctx, "(%s~=%s)",
760 tree->u.equality.attr, s);
763 case LDB_OP_EXTENDED:
764 s = ldb_binary_encode(mem_ctx, tree->u.extended.value);
765 if (s == NULL) return NULL;
766 ret = talloc_asprintf(mem_ctx, "(%s%s%s%s:=%s)",
767 tree->u.extended.attr?tree->u.extended.attr:"",
768 tree->u.extended.dnAttributes?":dn":"",
769 tree->u.extended.rule_id?":":"",
770 tree->u.extended.rule_id?tree->u.extended.rule_id:"",
781 replace any occurances of an attribute name in the parse tree with a
784 void ldb_parse_tree_attr_replace(struct ldb_parse_tree *tree,
789 switch (tree->operation) {
792 for (i=0;i<tree->u.list.num_elements;i++) {
793 ldb_parse_tree_attr_replace(tree->u.list.elements[i],
798 ldb_parse_tree_attr_replace(tree->u.isnot.child, attr, replace);
800 case LDB_OP_EQUALITY:
804 if (ldb_attr_cmp(tree->u.equality.attr, attr) == 0) {
805 tree->u.equality.attr = replace;
808 case LDB_OP_SUBSTRING:
809 if (ldb_attr_cmp(tree->u.substring.attr, attr) == 0) {
810 tree->u.substring.attr = replace;
814 if (ldb_attr_cmp(tree->u.present.attr, attr) == 0) {
815 tree->u.present.attr = replace;
818 case LDB_OP_EXTENDED:
819 if (tree->u.extended.attr &&
820 ldb_attr_cmp(tree->u.extended.attr, attr) == 0) {
821 tree->u.extended.attr = replace;