4 Copyright (C) Andrew Tridgell 2004-2005
5 Copyright (C) Simo Sorce 2005
7 ** NOTE! The following LGPL license applies to the ldb
8 ** library. This does NOT imply that all of Samba is released
11 This library is free software; you can redistribute it and/or
12 modify it under the terms of the GNU Lesser General Public
13 License as published by the Free Software Foundation; either
14 version 3 of the License, or (at your option) any later version.
16 This library is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 Lesser General Public License for more details.
21 You should have received a copy of the GNU Lesser General Public
22 License along with this library; if not, see <http://www.gnu.org/licenses/>.
28 * Component: ldb expression matching
30 * Description: ldb expression matching
32 * Author: Andrew Tridgell
35 #include "ldb_private.h"
38 check if the scope matches in a search result
40 static int ldb_match_scope(struct ldb_context
*ldb
,
47 if (base
== NULL
|| dn
== NULL
) {
53 if (ldb_dn_compare(base
, dn
) == 0) {
58 case LDB_SCOPE_ONELEVEL
:
59 if (ldb_dn_get_comp_num(dn
) == (ldb_dn_get_comp_num(base
) + 1)) {
60 if (ldb_dn_compare_base(base
, dn
) == 0) {
66 case LDB_SCOPE_SUBTREE
:
68 if (ldb_dn_compare_base(base
, dn
) == 0) {
79 match if node is present
81 static int ldb_match_present(struct ldb_context
*ldb
,
82 const struct ldb_message
*msg
,
83 const struct ldb_parse_tree
*tree
,
86 if (ldb_attr_dn(tree
->u
.present
.attr
) == 0) {
90 if (ldb_msg_find_element(msg
, tree
->u
.present
.attr
)) {
97 static int ldb_match_comparison(struct ldb_context
*ldb
,
98 const struct ldb_message
*msg
,
99 const struct ldb_parse_tree
*tree
,
100 enum ldb_scope scope
,
101 enum ldb_parse_op comp_op
)
104 struct ldb_message_element
*el
;
105 const struct ldb_schema_attribute
*a
;
108 /* FIXME: APPROX comparison not handled yet */
109 if (comp_op
== LDB_OP_APPROX
) return 0;
111 el
= ldb_msg_find_element(msg
, tree
->u
.comparison
.attr
);
116 a
= ldb_schema_attribute_by_name(ldb
, el
->name
);
118 for (i
= 0; i
< el
->num_values
; i
++) {
119 ret
= a
->syntax
->comparison_fn(ldb
, ldb
, &el
->values
[i
], &tree
->u
.comparison
.value
);
124 if (ret
> 0 && comp_op
== LDB_OP_GREATER
) {
127 if (ret
< 0 && comp_op
== LDB_OP_LESS
) {
136 match a simple leaf node
138 static int ldb_match_equality(struct ldb_context
*ldb
,
139 const struct ldb_message
*msg
,
140 const struct ldb_parse_tree
*tree
,
141 enum ldb_scope scope
)
144 struct ldb_message_element
*el
;
145 const struct ldb_schema_attribute
*a
;
146 struct ldb_dn
*valuedn
;
149 if (ldb_attr_dn(tree
->u
.equality
.attr
) == 0) {
150 valuedn
= ldb_dn_from_ldb_val(ldb
, ldb
, &tree
->u
.equality
.value
);
151 if (valuedn
== NULL
) {
155 ret
= ldb_dn_compare(msg
->dn
, valuedn
);
157 talloc_free(valuedn
);
159 if (ret
== 0) return 1;
163 /* TODO: handle the "*" case derived from an extended search
164 operation without the attibute type defined */
165 el
= ldb_msg_find_element(msg
, tree
->u
.equality
.attr
);
170 a
= ldb_schema_attribute_by_name(ldb
, el
->name
);
172 for (i
=0;i
<el
->num_values
;i
++) {
173 if (a
->syntax
->comparison_fn(ldb
, ldb
, &tree
->u
.equality
.value
,
174 &el
->values
[i
]) == 0) {
182 static int ldb_wildcard_compare(struct ldb_context
*ldb
,
183 const struct ldb_parse_tree
*tree
,
184 const struct ldb_val value
)
186 const struct ldb_schema_attribute
*a
;
189 struct ldb_val
*chunk
;
191 uint8_t *save_p
= NULL
;
194 a
= ldb_schema_attribute_by_name(ldb
, tree
->u
.substring
.attr
);
196 if(a
->syntax
->canonicalise_fn(ldb
, ldb
, &value
, &val
) != 0)
202 if ( ! tree
->u
.substring
.start_with_wildcard
) {
204 chunk
= tree
->u
.substring
.chunks
[c
];
205 if(a
->syntax
->canonicalise_fn(ldb
, ldb
, chunk
, &cnk
) != 0) goto failed
;
207 /* This deals with wildcard prefix searches on binary attributes (eg objectGUID) */
208 if (cnk
.length
> val
.length
) {
211 if (memcmp((char *)val
.data
, (char *)cnk
.data
, cnk
.length
) != 0) goto failed
;
212 val
.length
-= cnk
.length
;
213 val
.data
+= cnk
.length
;
215 talloc_free(cnk
.data
);
219 while (tree
->u
.substring
.chunks
[c
]) {
221 chunk
= tree
->u
.substring
.chunks
[c
];
222 if(a
->syntax
->canonicalise_fn(ldb
, ldb
, chunk
, &cnk
) != 0) goto failed
;
224 /* FIXME: case of embedded nulls */
225 p
= strstr((char *)val
.data
, (char *)cnk
.data
);
226 if (p
== NULL
) goto failed
;
227 if ( (! tree
->u
.substring
.chunks
[c
+ 1]) && (! tree
->u
.substring
.end_with_wildcard
) ) {
229 g
= strstr((char *)p
+ cnk
.length
, (char *)cnk
.data
);
233 val
.length
= val
.length
- (p
- (char *)(val
.data
)) - cnk
.length
;
234 val
.data
= (uint8_t *)(p
+ cnk
.length
);
236 talloc_free(cnk
.data
);
240 if ( (! tree
->u
.substring
.end_with_wildcard
) && (*(val
.data
) != 0) ) goto failed
; /* last chunk have not reached end of string */
246 talloc_free(cnk
.data
);
251 match a simple leaf node
253 static int ldb_match_substring(struct ldb_context
*ldb
,
254 const struct ldb_message
*msg
,
255 const struct ldb_parse_tree
*tree
,
256 enum ldb_scope scope
)
259 struct ldb_message_element
*el
;
261 el
= ldb_msg_find_element(msg
, tree
->u
.substring
.attr
);
266 for (i
= 0; i
< el
->num_values
; i
++) {
267 if (ldb_wildcard_compare(ldb
, tree
, el
->values
[i
]) == 1) {
277 bitwise-and comparator
279 static int ldb_comparator_and(const struct ldb_val
*v1
, const struct ldb_val
*v2
)
282 i1
= strtoull((char *)v1
->data
, NULL
, 0);
283 i2
= strtoull((char *)v2
->data
, NULL
, 0);
284 return ((i1
& i2
) == i2
);
288 bitwise-or comparator
290 static int ldb_comparator_or(const struct ldb_val
*v1
, const struct ldb_val
*v2
)
293 i1
= strtoull((char *)v1
->data
, NULL
, 0);
294 i2
= strtoull((char *)v2
->data
, NULL
, 0);
295 return ((i1
& i2
) != 0);
300 extended match, handles things like bitops
302 static int ldb_match_extended(struct ldb_context
*ldb
,
303 const struct ldb_message
*msg
,
304 const struct ldb_parse_tree
*tree
,
305 enum ldb_scope scope
)
310 int (*comparator
)(const struct ldb_val
*, const struct ldb_val
*);
312 { LDB_OID_COMPARATOR_AND
, ldb_comparator_and
},
313 { LDB_OID_COMPARATOR_OR
, ldb_comparator_or
}
315 int (*comp
)(const struct ldb_val
*, const struct ldb_val
*) = NULL
;
316 struct ldb_message_element
*el
;
318 if (tree
->u
.extended
.dnAttributes
) {
319 /* FIXME: We really need to find out what this ":dn" part in
320 * an extended match means and how to handle it. For now print
321 * only a warning to have s3 winbind and other tools working
322 * against us. - Matthias */
323 ldb_debug(ldb
, LDB_DEBUG_WARNING
, "ldb: dnAttributes extended match not supported yet");
325 if (tree
->u
.extended
.rule_id
== NULL
) {
326 ldb_debug(ldb
, LDB_DEBUG_ERROR
, "ldb: no-rule extended matches not supported yet");
329 if (tree
->u
.extended
.attr
== NULL
) {
330 ldb_debug(ldb
, LDB_DEBUG_ERROR
, "ldb: no-attribute extended matches not supported yet");
334 for (i
=0;i
<ARRAY_SIZE(rules
);i
++) {
335 if (strcmp(rules
[i
].oid
, tree
->u
.extended
.rule_id
) == 0) {
336 comp
= rules
[i
].comparator
;
341 ldb_debug(ldb
, LDB_DEBUG_ERROR
, "ldb: unknown extended rule_id %s",
342 tree
->u
.extended
.rule_id
);
346 /* find the message element */
347 el
= ldb_msg_find_element(msg
, tree
->u
.extended
.attr
);
352 for (i
=0;i
<el
->num_values
;i
++) {
353 int ret
= comp(&el
->values
[i
], &tree
->u
.extended
.value
);
354 if (ret
== -1 || ret
== 1) return ret
;
361 return 0 if the given parse tree matches the given message. Assumes
362 the message is in sorted order
364 return 1 if it matches, and 0 if it doesn't match
366 this is a recursive function, and does short-circuit evaluation
368 static int ldb_match_message(struct ldb_context
*ldb
,
369 const struct ldb_message
*msg
,
370 const struct ldb_parse_tree
*tree
,
371 enum ldb_scope scope
)
376 switch (tree
->operation
) {
378 for (i
=0;i
<tree
->u
.list
.num_elements
;i
++) {
379 v
= ldb_match_message(ldb
, msg
, tree
->u
.list
.elements
[i
], scope
);
385 for (i
=0;i
<tree
->u
.list
.num_elements
;i
++) {
386 v
= ldb_match_message(ldb
, msg
, tree
->u
.list
.elements
[i
], scope
);
392 return ! ldb_match_message(ldb
, msg
, tree
->u
.isnot
.child
, scope
);
394 case LDB_OP_EQUALITY
:
395 return ldb_match_equality(ldb
, msg
, tree
, scope
);
397 case LDB_OP_SUBSTRING
:
398 return ldb_match_substring(ldb
, msg
, tree
, scope
);
401 return ldb_match_comparison(ldb
, msg
, tree
, scope
, LDB_OP_GREATER
);
404 return ldb_match_comparison(ldb
, msg
, tree
, scope
, LDB_OP_LESS
);
407 return ldb_match_present(ldb
, msg
, tree
, scope
);
410 return ldb_match_comparison(ldb
, msg
, tree
, scope
, LDB_OP_APPROX
);
412 case LDB_OP_EXTENDED
:
413 return ldb_match_extended(ldb
, msg
, tree
, scope
);
420 int ldb_match_msg(struct ldb_context
*ldb
,
421 const struct ldb_message
*msg
,
422 const struct ldb_parse_tree
*tree
,
424 enum ldb_scope scope
)
426 if ( ! ldb_match_scope(ldb
, base
, msg
->dn
, scope
) ) {
430 return ldb_match_message(ldb
, msg
, tree
, scope
);
433 int ldb_match_msg_objectclass(const struct ldb_message
*msg
,
434 const char *objectclass
)
437 struct ldb_message_element
*el
= ldb_msg_find_element(msg
, "objectClass");
441 for (i
=0; i
< el
->num_values
; i
++) {
442 if (ldb_attr_cmp((const char *)el
->values
[i
].data
, objectclass
) == 0) {