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/>.
25 #include "lib/ldb_compat.h"
27 static struct ldb_parse_tree *ldb_parse_filter(void *mem_ctx, const char **s);
29 static int ldb_parse_hex2char(const char *x)
31 if (isxdigit(x[0]) && isxdigit(x[1])) {
32 const char h1 = x[0], h2 = x[1];
35 if (h1 >= 'a') c = h1 - (int)'a' + 10;
36 else if (h1 >= 'A') c = h1 - (int)'A' + 10;
37 else if (h1 >= '0') c = h1 - (int)'0';
39 if (h2 >= 'a') c += h2 - (int)'a' + 10;
40 else if (h2 >= 'A') c += h2 - (int)'A' + 10;
41 else if (h2 >= '0') c += h2 - (int)'0';
52 decode a RFC2254 binary string representation of a buffer.
55 static struct ldb_val ldb_binary_decode(void *mem_ctx, const char *str)
59 size_t slen = str?strlen(str):0;
61 ret.data = (uint8_t *)talloc_size(mem_ctx, slen+1);
63 if (ret.data == NULL) return ret;
65 for (i=j=0;i<slen;i++) {
69 c = ldb_parse_hex2char(&str[i+1]);
71 talloc_free(ret.data);
72 memset(&ret, 0, sizeof(ret));
75 ((uint8_t *)ret.data)[j++] = c;
78 ((uint8_t *)ret.data)[j++] = str[i];
82 ((uint8_t *)ret.data)[j] = 0;
91 encode a blob as a RFC2254 binary string, escaping any
92 non-printable or '\' characters
94 char *ldb_binary_encode(void *mem_ctx, struct ldb_val val)
98 size_t len = val.length;
99 unsigned char *buf = val.data;
101 for (i=0;i<val.length;i++) {
102 if (!isprint(buf[i]) || strchr(" *()\\&|!\"", buf[i])) {
106 ret = talloc_array(mem_ctx, char, len+1);
107 if (ret == NULL) return NULL;
110 for (i=0;i<val.length;i++) {
111 if (!isprint(buf[i]) || strchr(" *()\\&|!\"", buf[i])) {
112 snprintf(ret+len, 4, "\\%02X", buf[i]);
126 static enum ldb_parse_op ldb_parse_filtertype(void *mem_ctx, char **type, char **value, const char **s)
128 enum ldb_parse_op filter = 0;
129 char *name, *val, *k;
133 /* retrieve attributetype name */
136 if (*p == '@') { /* for internal attributes the first char can be @ */
140 while ((isascii(*p) && isalnum((unsigned char)*p)) || (*p == '-') || (*p == '.')) {
141 /* attribute names can only be alphanums */
145 if (*p == ':') { /* but extended searches have : and . chars too */
147 if (p == NULL) { /* malformed attribute name */
154 while (isspace((unsigned char)*p)) p++;
156 if (!strchr("=<>~:", *p)) {
161 name = (char *)talloc_memdup(mem_ctx, t, t1 - t + 1);
162 if (name == NULL) return 0;
165 /* retrieve filtertype */
168 filter = LDB_OP_EQUALITY;
169 } else if (*(p + 1) == '=') {
172 filter = LDB_OP_LESS;
176 filter = LDB_OP_GREATER;
180 filter = LDB_OP_APPROX;
184 filter = LDB_OP_EXTENDED;
195 while (isspace((unsigned char)*p)) p++;
200 while (*p && ((*p != ')') || ((*p == ')') && (*(p - 1) == '\\')))) p++;
202 val = (char *)talloc_memdup(mem_ctx, t, p - t + 1);
211 /* remove trailing spaces from value */
212 while ((k > val) && (isspace((unsigned char)*(k - 1)))) k--;
221 /* find the first matching wildcard */
222 static char *ldb_parse_find_wildcard(char *value)
225 value = strpbrk(value, "\\*");
226 if (value == NULL) return NULL;
228 if (value[0] == '\\') {
229 if (value[1] == '\0') return NULL;
234 if (value[0] == '*') return value;
240 /* return a NULL terminated list of binary strings representing the value
241 chunks separated by wildcards that makes the value portion of the filter
243 static struct ldb_val **ldb_wildcard_decode(void *mem_ctx, const char *string)
245 struct ldb_val **ret = NULL;
246 unsigned int val = 0;
249 wc = talloc_strdup(mem_ctx, string);
250 if (wc == NULL) return NULL;
254 wc = ldb_parse_find_wildcard(str);
264 ret = talloc_realloc(mem_ctx, ret, struct ldb_val *, val + 2);
265 if (ret == NULL) return NULL;
267 ret[val] = talloc(mem_ctx, struct ldb_val);
268 if (ret[val] == NULL) return NULL;
270 *(ret[val]) = ldb_binary_decode(mem_ctx, str);
271 if ((ret[val])->data == NULL) return NULL;
284 parse an extended match
292 the ':dn' part sets the dnAttributes boolean if present
293 the oid sets the rule_id string
296 static struct ldb_parse_tree *ldb_parse_extended(struct ldb_parse_tree *ret,
297 char *attr, char *value)
301 ret->operation = LDB_OP_EXTENDED;
302 ret->u.extended.value = ldb_binary_decode(ret, value);
303 if (ret->u.extended.value.data == NULL) goto failed;
305 p1 = strchr(attr, ':');
306 if (p1 == NULL) goto failed;
307 p2 = strchr(p1+1, ':');
312 ret->u.extended.attr = attr;
313 if (strcmp(p1+1, "dn") == 0) {
314 ret->u.extended.dnAttributes = 1;
316 ret->u.extended.rule_id = talloc_strdup(ret, p2+1);
317 if (ret->u.extended.rule_id == NULL) goto failed;
319 ret->u.extended.rule_id = NULL;
322 ret->u.extended.dnAttributes = 0;
323 ret->u.extended.rule_id = talloc_strdup(ret, p1+1);
324 if (ret->u.extended.rule_id == NULL) goto failed;
336 <simple> ::= <attributetype> <filtertype> <attributevalue>
338 static struct ldb_parse_tree *ldb_parse_simple(void *mem_ctx, const char **s)
341 struct ldb_parse_tree *ret;
342 enum ldb_parse_op filtertype;
344 ret = talloc(mem_ctx, struct ldb_parse_tree);
350 filtertype = ldb_parse_filtertype(ret, &attr, &value, s);
356 switch (filtertype) {
359 ret->operation = LDB_OP_PRESENT;
360 ret->u.present.attr = attr;
363 case LDB_OP_EQUALITY:
365 if (strcmp(value, "*") == 0) {
366 ret->operation = LDB_OP_PRESENT;
367 ret->u.present.attr = attr;
371 if (ldb_parse_find_wildcard(value) != NULL) {
372 ret->operation = LDB_OP_SUBSTRING;
373 ret->u.substring.attr = attr;
374 ret->u.substring.start_with_wildcard = 0;
375 ret->u.substring.end_with_wildcard = 0;
376 ret->u.substring.chunks = ldb_wildcard_decode(ret, value);
377 if (ret->u.substring.chunks == NULL){
382 ret->u.substring.start_with_wildcard = 1;
383 if (value[strlen(value) - 1] == '*')
384 ret->u.substring.end_with_wildcard = 1;
390 ret->operation = LDB_OP_EQUALITY;
391 ret->u.equality.attr = attr;
392 ret->u.equality.value = ldb_binary_decode(ret, value);
393 if (ret->u.equality.value.data == NULL) {
401 ret->operation = LDB_OP_GREATER;
402 ret->u.comparison.attr = attr;
403 ret->u.comparison.value = ldb_binary_decode(ret, value);
404 if (ret->u.comparison.value.data == NULL) {
412 ret->operation = LDB_OP_LESS;
413 ret->u.comparison.attr = attr;
414 ret->u.comparison.value = ldb_binary_decode(ret, value);
415 if (ret->u.comparison.value.data == NULL) {
423 ret->operation = LDB_OP_APPROX;
424 ret->u.comparison.attr = attr;
425 ret->u.comparison.value = ldb_binary_decode(ret, value);
426 if (ret->u.comparison.value.data == NULL) {
433 case LDB_OP_EXTENDED:
435 ret = ldb_parse_extended(ret, attr, value);
448 <and> ::= '&' <filterlist>
449 <or> ::= '|' <filterlist>
450 <filterlist> ::= <filter> | <filter> <filterlist>
452 static struct ldb_parse_tree *ldb_parse_filterlist(void *mem_ctx, const char **s)
454 struct ldb_parse_tree *ret, *next;
455 enum ldb_parse_op op;
470 while (isspace((unsigned char)*p)) p++;
472 ret = talloc(mem_ctx, struct ldb_parse_tree);
479 ret->u.list.num_elements = 1;
480 ret->u.list.elements = talloc(ret, struct ldb_parse_tree *);
481 if (!ret->u.list.elements) {
487 ret->u.list.elements[0] = ldb_parse_filter(ret->u.list.elements, &p);
488 if (!ret->u.list.elements[0]) {
493 while (isspace((unsigned char)*p)) p++;
495 while (*p && (next = ldb_parse_filter(ret->u.list.elements, &p))) {
496 struct ldb_parse_tree **e;
497 e = talloc_realloc(ret, ret->u.list.elements,
498 struct ldb_parse_tree *,
499 ret->u.list.num_elements + 1);
505 ret->u.list.elements = e;
506 ret->u.list.elements[ret->u.list.num_elements] = next;
507 ret->u.list.num_elements++;
508 while (isspace((unsigned char)*p)) p++;
517 <not> ::= '!' <filter>
519 static struct ldb_parse_tree *ldb_parse_not(void *mem_ctx, const char **s)
521 struct ldb_parse_tree *ret;
529 ret = talloc(mem_ctx, struct ldb_parse_tree);
535 ret->operation = LDB_OP_NOT;
536 ret->u.isnot.child = ldb_parse_filter(ret, &p);
537 if (!ret->u.isnot.child) {
551 <filtercomp> ::= <and> | <or> | <not> | <simple>
553 static struct ldb_parse_tree *ldb_parse_filtercomp(void *mem_ctx, const char **s)
555 struct ldb_parse_tree *ret;
558 while (isspace((unsigned char)*p)) p++;
562 ret = ldb_parse_filterlist(mem_ctx, &p);
566 ret = ldb_parse_filterlist(mem_ctx, &p);
570 ret = ldb_parse_not(mem_ctx, &p);
578 ret = ldb_parse_simple(mem_ctx, &p);
589 <filter> ::= '(' <filtercomp> ')'
591 static struct ldb_parse_tree *ldb_parse_filter(void *mem_ctx, const char **s)
593 struct ldb_parse_tree *ret;
601 ret = ldb_parse_filtercomp(mem_ctx, &p);
608 while (isspace((unsigned char)*p)) {
620 main parser entry point. Takes a search string and returns a parse tree
622 expression ::= <simple> | <filter>
624 struct ldb_parse_tree *ldb_parse_tree(void *mem_ctx, const char *s)
626 if (s == NULL || *s == 0) {
627 s = "(|(objectClass=*)(distinguishedName=*))";
630 while (isspace((unsigned char)*s)) s++;
633 return ldb_parse_filter(mem_ctx, &s);
636 return ldb_parse_simple(mem_ctx, &s);