1 /*
2 * SysDB - src/core/store_lookup.c
3 * Copyright (C) 2014 Sebastian 'tokkee' Harl <sh@tokkee.org>
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
17 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
19 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
28 /*
29 * This module implements operators which may be used to select contents of
30 * the store by matching various attributes of the stored objects. For now, a
31 * simple full table scan is supported only.
32 */
34 #if HAVE_CONFIG_H
35 # include "config.h"
36 #endif /* HAVE_CONFIG_H */
38 #include "sysdb.h"
39 #include "core/store-private.h"
40 #include "core/object.h"
42 #include <assert.h>
44 #include <sys/types.h>
45 #include <regex.h>
47 #include <stdlib.h>
48 #include <string.h>
50 #include <limits.h>
52 /*
53 * private data types
54 */
56 typedef struct {
57 sdb_store_matcher_t *m;
58 sdb_store_matcher_t *filter;
59 sdb_store_lookup_cb cb;
60 void *user_data;
61 } scan_iter_data_t;
63 /*
64 * private helper functions
65 */
67 static int
68 scan_iter(sdb_store_obj_t *obj, void *user_data)
69 {
70 scan_iter_data_t *d = user_data;
72 if (sdb_store_matcher_matches(d->m, obj, d->filter))
73 return d->cb(obj, d->user_data);
74 return 0;
75 } /* scan_iter */
77 static sdb_attribute_t *
78 attr_get(sdb_host_t *host, const char *name, sdb_store_matcher_t *filter)
79 {
80 sdb_avltree_iter_t *iter = NULL;
81 sdb_attribute_t *attr = NULL;
83 iter = sdb_avltree_get_iter(host->attributes);
84 while (sdb_avltree_iter_has_next(iter)) {
85 sdb_attribute_t *a = ATTR(sdb_avltree_iter_get_next(iter));
87 if (strcasecmp(name, SDB_OBJ(a)->name))
88 continue;
90 assert(STORE_OBJ(a)->type == SDB_ATTRIBUTE);
91 attr = a;
92 break;
93 }
94 sdb_avltree_iter_destroy(iter);
96 if (filter && (! sdb_store_matcher_matches(filter, STORE_OBJ(attr),
97 NULL)))
98 return NULL;
99 return attr;
100 } /* attr_get */
102 /*
103 * conditional implementations
104 */
106 static int
107 attr_cmp(sdb_store_obj_t *obj, sdb_store_cond_t *cond,
108 sdb_store_matcher_t *filter)
109 {
110 sdb_attribute_t *attr;
111 sdb_data_t value = SDB_DATA_INIT;
112 int status;
114 if (obj->type != SDB_HOST)
115 return INT_MAX;
117 if (sdb_store_expr_eval(ATTR_C(cond)->expr, obj, &value, filter))
118 return INT_MAX;
120 attr = attr_get(HOST(obj), ATTR_C(cond)->name, filter);
121 if (! attr)
122 status = INT_MAX;
123 else if (attr->value.type != value.type)
124 status = sdb_data_strcmp(&attr->value, &value);
125 else
126 status = sdb_data_cmp(&attr->value, &value);
127 sdb_data_free_datum(&value);
128 return status;
129 } /* attr_cmp */
131 static int
132 obj_cmp(sdb_store_obj_t *obj, sdb_store_cond_t *cond,
133 sdb_store_matcher_t *filter)
134 {
135 sdb_data_t obj_value = SDB_DATA_INIT;
136 sdb_data_t value = SDB_DATA_INIT;
137 int status;
139 if (sdb_store_expr_eval(OBJ_C(cond)->expr, obj, &value, filter))
140 return INT_MAX;
142 if (OBJ_C(cond)->field == SDB_FIELD_BACKEND) {
143 /* this implementation is not actually a conditional but rather checks
144 * for equality (or rather, existence) only */
145 size_t i;
147 if (value.type != SDB_TYPE_STRING)
148 return INT_MAX;
150 status = INT_MAX;
151 for (i = 0; i < obj->backends_num; ++i) {
152 if (! strcasecmp(obj->backends[i], value.data.string)) {
153 status = 0;
154 break;
155 }
156 }
157 sdb_data_free_datum(&value);
158 return status;
159 }
161 if (sdb_store_get_field(obj, OBJ_C(cond)->field, &obj_value))
162 return INT_MAX;
163 if (obj_value.type != value.type) {
164 sdb_data_free_datum(&obj_value);
165 sdb_data_free_datum(&value);
166 return INT_MAX;
167 }
169 status = sdb_data_cmp(&obj_value, &value);
170 sdb_data_free_datum(&obj_value);
171 sdb_data_free_datum(&value);
172 return status;
173 } /* obj_cmp */
175 /*
176 * matcher implementations
177 */
179 static int
180 match_string(string_matcher_t *m, const char *name)
181 {
182 if ((! m->name) && (! m->name_re))
183 return 1;
185 if (! name)
186 name = "";
188 if (m->name && strcasecmp(m->name, name))
189 return 0;
190 if (m->name_re && regexec(m->name_re, name,
191 /* matches */ 0, NULL, /* flags = */ 0))
192 return 0;
193 return 1;
194 } /* match_string */
196 static int
197 match_logical(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
198 sdb_store_matcher_t *filter)
199 {
200 int status;
202 assert((m->type == MATCHER_AND) || (m->type == MATCHER_OR));
203 assert(OP_M(m)->left && OP_M(m)->right);
205 status = sdb_store_matcher_matches(OP_M(m)->left, obj, filter);
207 /* lazy evaluation */
208 if ((! status) && (m->type == MATCHER_AND))
209 return status;
210 else if (status && (m->type == MATCHER_OR))
211 return status;
213 return sdb_store_matcher_matches(OP_M(m)->right, obj, filter);
214 } /* match_logical */
216 static int
217 match_unary(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
218 sdb_store_matcher_t *filter)
219 {
220 assert(m->type == MATCHER_NOT);
221 assert(UOP_M(m)->op);
223 return !sdb_store_matcher_matches(UOP_M(m)->op, obj, filter);
224 } /* match_unary */
226 static int
227 match_name(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
228 sdb_store_matcher_t *filter)
229 {
230 sdb_avltree_iter_t *iter = NULL;
231 int status = 0;
233 assert(m->type == MATCHER_NAME);
235 if (obj->type == NAME_M(m)->obj_type)
236 return match_string(&NAME_M(m)->name, SDB_OBJ(obj)->name);
237 else if (obj->type != SDB_HOST)
238 return 0;
240 switch (NAME_M(m)->obj_type) {
241 case SDB_SERVICE:
242 iter = sdb_avltree_get_iter(HOST(obj)->services);
243 break;
244 case SDB_METRIC:
245 iter = sdb_avltree_get_iter(HOST(obj)->metrics);
246 break;
247 case SDB_ATTRIBUTE:
248 iter = sdb_avltree_get_iter(HOST(obj)->attributes);
249 break;
250 }
252 while (sdb_avltree_iter_has_next(iter)) {
253 sdb_object_t *child = sdb_avltree_iter_get_next(iter);
254 if (filter && (! sdb_store_matcher_matches(filter, STORE_OBJ(child),
255 NULL)))
256 continue;
257 if (match_string(&NAME_M(m)->name, child->name)) {
258 status = 1;
259 break;
260 }
261 }
262 sdb_avltree_iter_destroy(iter);
263 return status;
264 } /* match_name */
266 static int
267 match_attr(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
268 sdb_store_matcher_t *filter)
269 {
270 sdb_attribute_t *attr;
272 assert(m->type == MATCHER_ATTR);
273 assert(ATTR_M(m)->name);
275 if (obj->type != SDB_HOST)
276 return 0;
278 attr = attr_get(HOST(obj), ATTR_M(m)->name, filter);
279 if (attr) {
280 char buf[sdb_data_strlen(&attr->value) + 1];
281 if (sdb_data_format(&attr->value, buf, sizeof(buf), SDB_UNQUOTED) <= 0)
282 return 0;
283 if (match_string(&ATTR_M(m)->value, buf))
284 return 1;
285 }
286 return 0;
287 } /* match_attr */
289 static int
290 match_child(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
291 sdb_store_matcher_t *filter)
292 {
293 sdb_avltree_iter_t *iter = NULL;
294 int status = 0;
296 assert((m->type == MATCHER_SERVICE)
297 || (m->type == MATCHER_METRIC)
298 || (m->type == MATCHER_ATTRIBUTE));
300 /* TODO: support all object types */
301 if (obj->type != SDB_HOST)
302 return 0;
304 if (m->type == MATCHER_SERVICE)
305 iter = sdb_avltree_get_iter(HOST(obj)->services);
306 else if (m->type == MATCHER_METRIC)
307 iter = sdb_avltree_get_iter(HOST(obj)->metrics);
308 else if (m->type == SDB_ATTRIBUTE)
309 iter = sdb_avltree_get_iter(HOST(obj)->attributes);
311 while (sdb_avltree_iter_has_next(iter)) {
312 sdb_object_t *child = sdb_avltree_iter_get_next(iter);
313 if (filter && (! sdb_store_matcher_matches(filter,
314 STORE_OBJ(child), NULL)))
315 continue;
317 if (sdb_store_matcher_matches(CHILD_M(m)->m, obj, filter)) {
318 status = 1;
319 break;
320 }
321 }
322 sdb_avltree_iter_destroy(iter);
323 return status;
324 } /* match_child */
326 static int
327 match_lt(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
328 sdb_store_matcher_t *filter)
329 {
330 int status;
331 assert(m->type == MATCHER_LT);
332 status = COND_M(m)->cond->cmp(obj, COND_M(m)->cond, filter);
333 return (status != INT_MAX) && (status < 0);
334 } /* match_lt */
336 static int
337 match_le(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
338 sdb_store_matcher_t *filter)
339 {
340 int status;
341 assert(m->type == MATCHER_LE);
342 status = COND_M(m)->cond->cmp(obj, COND_M(m)->cond, filter);
343 return (status != INT_MAX) && (status <= 0);
344 } /* match_le */
346 static int
347 match_eq(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
348 sdb_store_matcher_t *filter)
349 {
350 int status;
351 assert(m->type == MATCHER_EQ);
352 status = COND_M(m)->cond->cmp(obj, COND_M(m)->cond, filter);
353 return (status != INT_MAX) && (! status);
354 } /* match_eq */
356 static int
357 match_ge(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
358 sdb_store_matcher_t *filter)
359 {
360 int status;
361 assert(m->type == MATCHER_GE);
362 status = COND_M(m)->cond->cmp(obj, COND_M(m)->cond, filter);
363 return (status != INT_MAX) && (status >= 0);
364 } /* match_ge */
366 static int
367 match_gt(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
368 sdb_store_matcher_t *filter)
369 {
370 int status;
371 assert(m->type == MATCHER_GT);
372 status = COND_M(m)->cond->cmp(obj, COND_M(m)->cond, filter);
373 return (status != INT_MAX) && (status > 0);
374 } /* match_gt */
376 /*
377 * cmp_expr:
378 * Compare the values of two expressions when evaluating them using the
379 * specified stored object and filter. Returns a value less than, equal to, or
380 * greater than zero if the value of the first expression compares less than,
381 * equal to, or greater than the value of the second expression. Returns
382 * INT_MAX if any of the expressions could not be evaluated.
383 */
384 static int
385 cmp_expr(sdb_store_expr_t *e1, sdb_store_expr_t *e2,
386 sdb_store_obj_t *obj, sdb_store_matcher_t *filter)
387 {
388 sdb_data_t v1 = SDB_DATA_INIT, v2 = SDB_DATA_INIT;
389 int status;
391 if (sdb_store_expr_eval(e1, obj, &v1, filter))
392 return INT_MAX;
393 if (sdb_store_expr_eval(e2, obj, &v2, filter)) {
394 sdb_data_free_datum(&v1);
395 return INT_MAX;
396 }
398 if (v1.type == v2.type)
399 status = sdb_data_cmp(&v1, &v2);
400 else
401 status = sdb_data_strcmp(&v1, &v2);
403 sdb_data_free_datum(&v1);
404 sdb_data_free_datum(&v2);
405 return status;
406 } /* cmp_expr */
408 static int
409 match_cmp_lt(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
410 sdb_store_matcher_t *filter)
411 {
412 int status;
413 assert(m->type == MATCHER_CMP_LT);
414 status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter);
415 return (status != INT_MAX) && (status < 0);
416 } /* match_cmp_lt */
418 static int
419 match_cmp_le(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
420 sdb_store_matcher_t *filter)
421 {
422 int status;
423 assert(m->type == MATCHER_CMP_LE);
424 status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter);
425 return (status != INT_MAX) && (status <= 0);
426 } /* match_cmp_le */
428 static int
429 match_cmp_eq(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
430 sdb_store_matcher_t *filter)
431 {
432 int status;
433 assert(m->type == MATCHER_CMP_EQ);
434 status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter);
435 return (status != INT_MAX) && (! status);
436 } /* match_cmp_eq */
438 static int
439 match_cmp_ne(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
440 sdb_store_matcher_t *filter)
441 {
442 int status;
443 assert(m->type == MATCHER_CMP_NE);
444 status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter);
445 return (status != INT_MAX) && status;
446 } /* match_cmp_ne */
448 static int
449 match_cmp_ge(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
450 sdb_store_matcher_t *filter)
451 {
452 int status;
453 assert(m->type == MATCHER_CMP_GE);
454 status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter);
455 return (status != INT_MAX) && (status >= 0);
456 } /* match_cmp_ge */
458 static int
459 match_cmp_gt(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
460 sdb_store_matcher_t *filter)
461 {
462 int status;
463 assert(m->type == MATCHER_CMP_GT);
464 status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter);
465 return (status != INT_MAX) && (status > 0);
466 } /* match_cmp_gt */
468 static int
469 match_regex(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
470 sdb_store_matcher_t *filter)
471 {
472 sdb_data_t v = SDB_DATA_INIT;
473 int status = 0;
475 regex_t regex;
476 _Bool free_regex = 0;
478 assert((m->type == MATCHER_REGEX)
479 || (m->type == MATCHER_NREGEX));
481 if (! CMP_M(m)->right->type) {
482 assert(CMP_M(m)->right->data.type == SDB_TYPE_REGEX);
483 regex = CMP_M(m)->right->data.data.re.regex;
484 }
485 else {
486 sdb_data_t tmp = SDB_DATA_INIT;
487 char *raw;
489 if (sdb_store_expr_eval(CMP_M(m)->right, obj, &tmp, filter))
490 return 0;
492 if (tmp.type != SDB_TYPE_STRING) {
493 sdb_data_free_datum(&tmp);
494 return 0;
495 }
497 raw = tmp.data.string;
498 if (sdb_data_parse(raw, SDB_TYPE_REGEX, &tmp)) {
499 free(raw);
500 return 0;
501 }
503 regex = tmp.data.re.regex;
504 free_regex = 1;
505 free(tmp.data.re.raw);
506 free(raw);
507 }
509 if (sdb_store_expr_eval(CMP_M(m)->left, obj, &v, filter))
510 status = 0;
511 else {
512 char value[sdb_data_strlen(&v) + 1];
513 if (sdb_data_format(&v, value, sizeof(value), SDB_UNQUOTED) < 0)
514 status = 0;
515 else if (! regexec(®ex, value, 0, NULL, 0))
516 status = 1;
517 }
519 if (free_regex)
520 regfree(®ex);
521 sdb_data_free_datum(&v);
522 if (m->type == MATCHER_NREGEX)
523 return !status;
524 return status;
525 } /* match_regex */
527 static int
528 match_isnull(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
529 sdb_store_matcher_t *filter)
530 {
531 sdb_data_t v = SDB_DATA_INIT;
532 int status;
534 assert((m->type == MATCHER_ISNULL) || (m->type == MATCHER_ISNNULL));
536 /* TODO: this might hide real errors;
537 * improve error reporting and propagation */
538 if (sdb_store_expr_eval(ISNULL_M(m)->expr, obj, &v, filter)
539 || sdb_data_isnull(&v))
540 status = 1;
541 else
542 status = 0;
544 sdb_data_free_datum(&v);
545 if (m->type == MATCHER_ISNNULL)
546 return !status;
547 return status;
548 } /* match_isnull */
550 typedef int (*matcher_cb)(sdb_store_matcher_t *, sdb_store_obj_t *,
551 sdb_store_matcher_t *);
553 /* this array needs to be indexable by the matcher types;
554 * -> update the enum in store-private.h when updating this */
555 static matcher_cb
556 matchers[] = {
557 match_logical,
558 match_logical,
559 match_unary,
560 match_name,
561 match_attr,
562 match_child,
563 match_child,
564 match_child,
565 match_lt,
566 match_le,
567 match_eq,
568 match_ge,
569 match_gt,
570 match_cmp_lt,
571 match_cmp_le,
572 match_cmp_eq,
573 match_cmp_ne,
574 match_cmp_ge,
575 match_cmp_gt,
576 match_regex,
577 match_regex,
578 match_isnull,
579 match_isnull,
580 };
582 /*
583 * private conditional types
584 */
586 static int
587 attr_cond_init(sdb_object_t *obj, va_list ap)
588 {
589 const char *name = va_arg(ap, const char *);
590 sdb_store_expr_t *expr = va_arg(ap, sdb_store_expr_t *);
592 if (! name)
593 return -1;
595 SDB_STORE_COND(obj)->cmp = attr_cmp;
597 ATTR_C(obj)->name = strdup(name);
598 if (! ATTR_C(obj)->name)
599 return -1;
600 ATTR_C(obj)->expr = expr;
601 sdb_object_ref(SDB_OBJ(expr));
602 return 0;
603 } /* attr_cond_init */
605 static void
606 attr_cond_destroy(sdb_object_t *obj)
607 {
608 if (ATTR_C(obj)->name)
609 free(ATTR_C(obj)->name);
610 sdb_object_deref(SDB_OBJ(ATTR_C(obj)->expr));
611 } /* attr_cond_destroy */
613 static sdb_type_t attr_cond_type = {
614 /* size = */ sizeof(attr_cond_t),
615 /* init = */ attr_cond_init,
616 /* destroy = */ attr_cond_destroy,
617 };
619 static int
620 obj_cond_init(sdb_object_t *obj, va_list ap)
621 {
622 int field = va_arg(ap, int);
623 sdb_store_expr_t *expr = va_arg(ap, sdb_store_expr_t *);
625 SDB_STORE_COND(obj)->cmp = obj_cmp;
627 OBJ_C(obj)->field = field;
628 OBJ_C(obj)->expr = expr;
629 sdb_object_ref(SDB_OBJ(expr));
630 return 0;
631 } /* obj_cond_init */
633 static void
634 obj_cond_destroy(sdb_object_t *obj)
635 {
636 sdb_object_deref(SDB_OBJ(OBJ_C(obj)->expr));
637 } /* obj_cond_destroy */
639 static sdb_type_t obj_cond_type = {
640 /* size = */ sizeof(obj_cond_t),
641 /* init = */ obj_cond_init,
642 /* destroy = */ obj_cond_destroy,
643 };
645 /*
646 * private matcher types
647 */
649 /* initializes a string matcher consuming two elements from ap */
650 static int
651 string_matcher_init(string_matcher_t *m, va_list ap)
652 {
653 const char *name = va_arg(ap, const char *);
654 const char *name_re = va_arg(ap, const char *);
656 if (name) {
657 m->name = strdup(name);
658 if (! m->name)
659 return -1;
660 }
661 if (name_re) {
662 m->name_re = malloc(sizeof(*m->name_re));
663 if (! m->name_re)
664 return -1;
665 if (regcomp(m->name_re, name_re, REG_EXTENDED | REG_ICASE | REG_NOSUB))
666 return -1;
667 }
668 return 0;
669 } /* string_matcher_init */
671 static void
672 string_matcher_destroy(string_matcher_t *m)
673 {
674 if (m->name)
675 free(m->name);
676 if (m->name_re) {
677 regfree(m->name_re);
678 free(m->name_re);
679 }
680 } /* string_matcher_destroy */
682 static char *
683 string_tostring(string_matcher_t *m, char *buf, size_t buflen)
684 {
685 snprintf(buf, buflen, "{ %s%s%s, %p }",
686 m->name ? "'" : "", m->name ? m->name : "NULL", m->name ? "'" : "",
687 m->name_re);
688 return buf;
689 } /* string_tostring */
691 /* initializes a name matcher */
692 static int
693 name_matcher_init(sdb_object_t *obj, va_list ap)
694 {
695 name_matcher_t *m = NAME_M(obj);
696 M(obj)->type = MATCHER_NAME;
697 return string_matcher_init(&m->name, ap);
698 } /* name_matcher_init */
700 static void
701 name_matcher_destroy(sdb_object_t *obj)
702 {
703 name_matcher_t *m = NAME_M(obj);
704 string_matcher_destroy(&m->name);
705 } /* name_matcher_destroy */
707 static char *
708 name_tostring(sdb_store_matcher_t *m, char *buf, size_t buflen)
709 {
710 char name[buflen + 1];
711 assert(m->type == MATCHER_NAME);
712 snprintf(buf, buflen, "OBJ[%s]{ NAME%s }",
713 SDB_STORE_TYPE_TO_NAME(NAME_M(m)->obj_type),
714 string_tostring(&NAME_M(m)->name, name, sizeof(name)));
715 return buf;
716 } /* name_tostring */
718 static int
719 attr_matcher_init(sdb_object_t *obj, va_list ap)
720 {
721 attr_matcher_t *attr = ATTR_M(obj);
722 const char *name = va_arg(ap, const char *);
724 M(obj)->type = MATCHER_ATTR;
725 if (name) {
726 attr->name = strdup(name);
727 if (! attr->name)
728 return -1;
729 }
730 return string_matcher_init(&attr->value, ap);
731 } /* attr_matcher_init */
733 static void
734 attr_matcher_destroy(sdb_object_t *obj)
735 {
736 attr_matcher_t *attr = ATTR_M(obj);
737 if (attr->name)
738 free(attr->name);
739 attr->name = NULL;
740 string_matcher_destroy(&attr->value);
741 } /* attr_matcher_destroy */
743 static char *
744 attr_tostring(sdb_store_matcher_t *m, char *buf, size_t buflen)
745 {
746 char value[buflen + 1];
748 if (! m) {
749 snprintf(buf, buflen, "ATTR{}");
750 return buf;
751 }
753 assert(m->type == MATCHER_ATTR);
754 snprintf(buf, buflen, "ATTR[%s]{ VALUE%s }", ATTR_M(m)->name,
755 string_tostring(&ATTR_M(m)->value, value, sizeof(value)));
756 return buf;
757 } /* attr_tostring */
759 static int
760 cond_matcher_init(sdb_object_t *obj, va_list ap)
761 {
762 int type = va_arg(ap, int);
763 sdb_store_cond_t *cond = va_arg(ap, sdb_store_cond_t *);
765 if (! cond)
766 return -1;
768 sdb_object_ref(SDB_OBJ(cond));
770 M(obj)->type = type;
771 COND_M(obj)->cond = cond;
772 return 0;
773 } /* cond_matcher_init */
775 static void
776 cond_matcher_destroy(sdb_object_t *obj)
777 {
778 sdb_object_deref(SDB_OBJ(COND_M(obj)->cond));
779 } /* cond_matcher_destroy */
781 static char *
782 cond_tostring(sdb_store_matcher_t *m, char *buf, size_t buflen)
783 {
784 const char *type, *id;
785 sdb_data_t value = SDB_DATA_INIT;
786 char value_str[buflen];
787 sdb_store_expr_t *expr;
789 if (COND_M(m)->cond->cmp == attr_cmp) {
790 type = "ATTR";
791 id = ATTR_C(COND_M(m)->cond)->name;
792 expr = ATTR_C(COND_M(m)->cond)->expr;
793 }
794 else if (COND_M(m)->cond->cmp == obj_cmp) {
795 type = "OBJ";
796 id = SDB_FIELD_TO_NAME(OBJ_C(COND_M(m)->cond)->field);
797 expr = OBJ_C(COND_M(m)->cond)->expr;
798 }
799 else {
800 snprintf(buf, buflen, "<unknown>");
801 return buf;
802 }
804 if (sdb_store_expr_eval(expr, /* obj */ NULL, &value, /* filter */ NULL))
805 snprintf(value_str, sizeof(value_str), "ERR");
806 else if (sdb_data_format(&value, value_str, sizeof(value_str),
807 SDB_SINGLE_QUOTED) < 0)
808 snprintf(value_str, sizeof(value_str), "ERR");
809 snprintf(buf, buflen, "%s[%s]{ %s %s }", type, id,
810 MATCHER_SYM(m->type), value_str);
811 sdb_data_free_datum(&value);
812 return buf;
813 } /* cond_tostring */
815 static int
816 op_matcher_init(sdb_object_t *obj, va_list ap)
817 {
818 M(obj)->type = va_arg(ap, int);
819 if ((M(obj)->type != MATCHER_OR) && (M(obj)->type != MATCHER_AND))
820 return -1;
822 OP_M(obj)->left = va_arg(ap, sdb_store_matcher_t *);
823 sdb_object_ref(SDB_OBJ(OP_M(obj)->left));
824 OP_M(obj)->right = va_arg(ap, sdb_store_matcher_t *);
825 sdb_object_ref(SDB_OBJ(OP_M(obj)->right));
827 if ((! OP_M(obj)->left) || (! OP_M(obj)->right))
828 return -1;
829 return 0;
830 } /* op_matcher_init */
832 static void
833 op_matcher_destroy(sdb_object_t *obj)
834 {
835 if (OP_M(obj)->left)
836 sdb_object_deref(SDB_OBJ(OP_M(obj)->left));
837 if (OP_M(obj)->right)
838 sdb_object_deref(SDB_OBJ(OP_M(obj)->right));
839 } /* op_matcher_destroy */
841 static char *
842 op_tostring(sdb_store_matcher_t *m, char *buf, size_t buflen)
843 {
844 char left[buflen + 1], right[buflen + 1];
846 if (! m) {
847 /* this should not happen */
848 snprintf(buf, buflen, "()");
849 return buf;
850 }
852 assert((m->type == MATCHER_OR) || (m->type == MATCHER_AND));
853 snprintf(buf, buflen, "(%s, %s, %s)",
854 m->type == MATCHER_OR ? "OR" : "AND",
855 sdb_store_matcher_tostring(OP_M(m)->left, left, sizeof(left)),
856 sdb_store_matcher_tostring(OP_M(m)->right, right, sizeof(right)));
857 return buf;
858 } /* op_tostring */
860 static int
861 child_matcher_init(sdb_object_t *obj, va_list ap)
862 {
863 M(obj)->type = va_arg(ap, int);
864 CHILD_M(obj)->m = va_arg(ap, sdb_store_matcher_t *);
866 if (! CHILD_M(obj)->m)
867 return -1;
869 sdb_object_ref(SDB_OBJ(CHILD_M(obj)->m));
870 return 0;
871 } /* child_matcher_init */
873 static void
874 child_matcher_destroy(sdb_object_t *obj)
875 {
876 sdb_object_deref(SDB_OBJ(CHILD_M(obj)->m));
877 } /* child_matcher_destroy */
879 static char *
880 child_tostring(sdb_store_matcher_t *m, char *buf, size_t buflen)
881 {
882 snprintf(buf, buflen, "%s:", MATCHER_SYM(m->type));
883 buf[buflen - 1] = '\0';
884 sdb_store_matcher_tostring(CHILD_M(m)->m,
885 buf + strlen(buf), buflen - strlen(buf));
886 return buf;
887 } /* child_tostring */
889 static int
890 cmp_matcher_init(sdb_object_t *obj, va_list ap)
891 {
892 M(obj)->type = va_arg(ap, int);
894 CMP_M(obj)->left = va_arg(ap, sdb_store_expr_t *);
895 sdb_object_ref(SDB_OBJ(CMP_M(obj)->left));
896 CMP_M(obj)->right = va_arg(ap, sdb_store_expr_t *);
897 sdb_object_ref(SDB_OBJ(CMP_M(obj)->right));
899 if ((! CMP_M(obj)->left) || (! CMP_M(obj)->right))
900 return -1;
901 return 0;
902 } /* cmp_matcher_init */
904 static void
905 cmp_matcher_destroy(sdb_object_t *obj)
906 {
907 sdb_object_deref(SDB_OBJ(CMP_M(obj)->left));
908 sdb_object_deref(SDB_OBJ(CMP_M(obj)->right));
909 } /* cmp_matcher_destroy */
911 static char *
912 cmp_tostring(sdb_store_matcher_t *m, char *buf, size_t buflen)
913 {
914 if (! m) {
915 /* this should not happen */
916 snprintf(buf, buflen, "()");
917 return buf;
918 }
920 /* TODO */
921 snprintf(buf, buflen, "CMP_MATCHER(%d)", m->type);
922 return buf;
923 } /* cmp_tostring */
925 static int
926 uop_matcher_init(sdb_object_t *obj, va_list ap)
927 {
928 M(obj)->type = va_arg(ap, int);
929 if (M(obj)->type != MATCHER_NOT)
930 return -1;
932 UOP_M(obj)->op = va_arg(ap, sdb_store_matcher_t *);
933 sdb_object_ref(SDB_OBJ(UOP_M(obj)->op));
935 if (! UOP_M(obj)->op)
936 return -1;
937 return 0;
938 } /* uop_matcher_init */
940 static void
941 uop_matcher_destroy(sdb_object_t *obj)
942 {
943 if (UOP_M(obj)->op)
944 sdb_object_deref(SDB_OBJ(UOP_M(obj)->op));
945 } /* uop_matcher_destroy */
947 static char *
948 uop_tostring(sdb_store_matcher_t *m, char *buf, size_t buflen)
949 {
950 char op[buflen + 1];
952 if (! m) {
953 /* this should not happen */
954 snprintf(buf, buflen, "()");
955 return buf;
956 }
958 assert(m->type == MATCHER_NOT);
959 snprintf(buf, buflen, "(NOT, %s)",
960 sdb_store_matcher_tostring(UOP_M(m)->op, op, sizeof(op)));
961 return buf;
962 } /* uop_tostring */
964 static int
965 isnull_matcher_init(sdb_object_t *obj, va_list ap)
966 {
967 M(obj)->type = va_arg(ap, int);
968 if ((M(obj)->type != MATCHER_ISNULL) && (M(obj)->type != MATCHER_ISNNULL))
969 return -1;
971 ISNULL_M(obj)->expr = va_arg(ap, sdb_store_expr_t *);
972 sdb_object_ref(SDB_OBJ(ISNULL_M(obj)->expr));
973 return 0;
974 } /* isnull_matcher_init */
976 static void
977 isnull_matcher_destroy(sdb_object_t *obj)
978 {
979 sdb_object_deref(SDB_OBJ(ISNULL_M(obj)->expr));
980 ISNULL_M(obj)->expr = NULL;
981 } /* isnull_matcher_destroy */
983 static char *
984 isnull_tostring(sdb_store_matcher_t *m, char *buf, size_t buflen)
985 {
986 /* XXX */
987 if (m->type == MATCHER_ISNULL)
988 strncpy(buf, "(IS NULL)", buflen);
989 else
990 strncpy(buf, "(IS NOT NULL)", buflen);
991 return buf;
992 } /* isnull_tostring */
994 static sdb_type_t name_type = {
995 /* size = */ sizeof(name_matcher_t),
996 /* init = */ name_matcher_init,
997 /* destroy = */ name_matcher_destroy,
998 };
1000 static sdb_type_t attr_type = {
1001 /* size = */ sizeof(attr_matcher_t),
1002 /* init = */ attr_matcher_init,
1003 /* destroy = */ attr_matcher_destroy,
1004 };
1006 static sdb_type_t cond_type = {
1007 /* size = */ sizeof(cond_matcher_t),
1008 /* init = */ cond_matcher_init,
1009 /* destroy = */ cond_matcher_destroy,
1010 };
1012 static sdb_type_t op_type = {
1013 /* size = */ sizeof(op_matcher_t),
1014 /* init = */ op_matcher_init,
1015 /* destroy = */ op_matcher_destroy,
1016 };
1018 static sdb_type_t uop_type = {
1019 /* size = */ sizeof(uop_matcher_t),
1020 /* init = */ uop_matcher_init,
1021 /* destroy = */ uop_matcher_destroy,
1022 };
1024 static sdb_type_t child_type = {
1025 /* size = */ sizeof(child_matcher_t),
1026 /* init = */ child_matcher_init,
1027 /* destroy = */ child_matcher_destroy,
1028 };
1030 static sdb_type_t cmp_type = {
1031 /* size = */ sizeof(cmp_matcher_t),
1032 /* init = */ cmp_matcher_init,
1033 /* destroy = */ cmp_matcher_destroy,
1034 };
1036 static sdb_type_t isnull_type = {
1037 /* size = */ sizeof(isnull_matcher_t),
1038 /* init = */ isnull_matcher_init,
1039 /* destroy = */ isnull_matcher_destroy,
1040 };
1042 typedef char *(*matcher_tostring_cb)(sdb_store_matcher_t *, char *, size_t);
1044 /* this array needs to be indexable by the matcher types;
1045 * -> update the enum in store-private.h when updating this */
1046 static matcher_tostring_cb
1047 matchers_tostring[] = {
1048 op_tostring,
1049 op_tostring,
1050 uop_tostring,
1051 name_tostring,
1052 attr_tostring,
1053 child_tostring,
1054 child_tostring,
1055 child_tostring,
1056 cond_tostring,
1057 cond_tostring,
1058 cond_tostring,
1059 cond_tostring,
1060 cond_tostring,
1061 cmp_tostring,
1062 cmp_tostring,
1063 cmp_tostring,
1064 cmp_tostring,
1065 cmp_tostring,
1066 cmp_tostring,
1067 cmp_tostring,
1068 cmp_tostring,
1069 isnull_tostring,
1070 isnull_tostring,
1071 };
1073 /*
1074 * public API
1075 */
1077 sdb_store_cond_t *
1078 sdb_store_attr_cond(const char *name, sdb_store_expr_t *expr)
1079 {
1080 return SDB_STORE_COND(sdb_object_create("attr-cond", attr_cond_type,
1081 name, expr));
1082 } /* sdb_store_attr_cond */
1084 sdb_store_cond_t *
1085 sdb_store_obj_cond(int field, sdb_store_expr_t *expr)
1086 {
1087 return SDB_STORE_COND(sdb_object_create("obj-cond", obj_cond_type,
1088 field, expr));
1089 } /* sdb_store_obj_cond */
1091 sdb_store_matcher_t *
1092 sdb_store_name_matcher(int type, const char *name, _Bool re)
1093 {
1094 sdb_store_matcher_t *m;
1096 if (re)
1097 m = M(sdb_object_create("name-matcher", name_type, NULL, name));
1098 else
1099 m = M(sdb_object_create("name-matcher", name_type, name, NULL));
1101 if (! m)
1102 return NULL;
1104 NAME_M(m)->obj_type = type;
1105 return m;
1106 } /* sdb_store_name_matcher */
1108 sdb_store_matcher_t *
1109 sdb_store_attr_matcher(const char *name, const char *value, _Bool re)
1110 {
1111 sdb_store_matcher_t *m;
1113 if (! name)
1114 return NULL;
1116 if (re)
1117 m = M(sdb_object_create("attr-matcher", attr_type,
1118 name, NULL, value));
1119 else
1120 m = M(sdb_object_create("attr-matcher", attr_type,
1121 name, value, NULL));
1122 return m;
1123 } /* sdb_store_attr_matcher */
1125 sdb_store_matcher_t *
1126 sdb_store_child_matcher(int type, sdb_store_matcher_t *m)
1127 {
1128 if (type == SDB_SERVICE)
1129 type = MATCHER_SERVICE;
1130 else if (type == SDB_METRIC)
1131 type = MATCHER_METRIC;
1132 else if (type == SDB_ATTRIBUTE)
1133 type = MATCHER_ATTRIBUTE;
1134 else
1135 return NULL;
1136 return M(sdb_object_create("any-matcher", child_type, type, m));
1137 } /* sdb_store_child_matcher */
1139 sdb_store_matcher_t *
1140 sdb_store_lt_matcher(sdb_store_cond_t *cond)
1141 {
1142 return M(sdb_object_create("lt-matcher", cond_type,
1143 MATCHER_LT, cond));
1144 } /* sdb_store_lt_matcher */
1146 sdb_store_matcher_t *
1147 sdb_store_le_matcher(sdb_store_cond_t *cond)
1148 {
1149 return M(sdb_object_create("le-matcher", cond_type,
1150 MATCHER_LE, cond));
1151 } /* sdb_store_le_matcher */
1153 sdb_store_matcher_t *
1154 sdb_store_eq_matcher(sdb_store_cond_t *cond)
1155 {
1156 return M(sdb_object_create("eq-matcher", cond_type,
1157 MATCHER_EQ, cond));
1158 } /* sdb_store_eq_matcher */
1160 sdb_store_matcher_t *
1161 sdb_store_ge_matcher(sdb_store_cond_t *cond)
1162 {
1163 return M(sdb_object_create("ge-matcher", cond_type,
1164 MATCHER_GE, cond));
1165 } /* sdb_store_ge_matcher */
1167 sdb_store_matcher_t *
1168 sdb_store_gt_matcher(sdb_store_cond_t *cond)
1169 {
1170 return M(sdb_object_create("gt-matcher", cond_type,
1171 MATCHER_GT, cond));
1172 } /* sdb_store_gt_matcher */
1174 /*
1175 * TODO: Rename sdb_store_cmp_* to sdb_store_* once the old code is unused and
1176 * has been removed.
1177 */
1179 sdb_store_matcher_t *
1180 sdb_store_cmp_lt(sdb_store_expr_t *left, sdb_store_expr_t *right)
1181 {
1182 return M(sdb_object_create("lt-matcher", cmp_type,
1183 MATCHER_CMP_LT, left, right));
1184 } /* sdb_store_cmp_lt */
1186 sdb_store_matcher_t *
1187 sdb_store_cmp_le(sdb_store_expr_t *left, sdb_store_expr_t *right)
1188 {
1189 return M(sdb_object_create("le-matcher", cmp_type,
1190 MATCHER_CMP_LE, left, right));
1191 } /* sdb_store_cmp_le */
1193 sdb_store_matcher_t *
1194 sdb_store_cmp_eq(sdb_store_expr_t *left, sdb_store_expr_t *right)
1195 {
1196 return M(sdb_object_create("eq-matcher", cmp_type,
1197 MATCHER_CMP_EQ, left, right));
1198 } /* sdb_store_cmp_eq */
1200 sdb_store_matcher_t *
1201 sdb_store_cmp_ne(sdb_store_expr_t *left, sdb_store_expr_t *right)
1202 {
1203 return M(sdb_object_create("ne-matcher", cmp_type,
1204 MATCHER_CMP_NE, left, right));
1205 } /* sdb_store_cmp_ne */
1207 sdb_store_matcher_t *
1208 sdb_store_cmp_ge(sdb_store_expr_t *left, sdb_store_expr_t *right)
1209 {
1210 return M(sdb_object_create("ge-matcher", cmp_type,
1211 MATCHER_CMP_GE, left, right));
1212 } /* sdb_store_cmp_ge */
1214 sdb_store_matcher_t *
1215 sdb_store_cmp_gt(sdb_store_expr_t *left, sdb_store_expr_t *right)
1216 {
1217 return M(sdb_object_create("gt-matcher", cmp_type,
1218 MATCHER_CMP_GT, left, right));
1219 } /* sdb_store_cmp_gt */
1221 sdb_store_matcher_t *
1222 sdb_store_regex_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right)
1223 {
1224 if (! right->type) {
1225 if ((right->data.type != SDB_TYPE_STRING)
1226 && (right->data.type != SDB_TYPE_REGEX))
1227 return NULL;
1229 if (right->data.type == SDB_TYPE_STRING) {
1230 char *raw = right->data.data.string;
1231 if (sdb_data_parse(raw, SDB_TYPE_REGEX, &right->data))
1232 return NULL;
1233 free(raw);
1234 }
1235 }
1236 return M(sdb_object_create("regex-matcher", cmp_type,
1237 MATCHER_REGEX, left, right));
1238 } /* sdb_store_regex_matcher */
1240 sdb_store_matcher_t *
1241 sdb_store_nregex_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right)
1242 {
1243 sdb_store_matcher_t *m = sdb_store_regex_matcher(left, right);
1244 if (! m)
1245 return NULL;
1246 m->type = MATCHER_NREGEX;
1247 return m;
1248 } /* sdb_store_nregex_matcher */
1250 sdb_store_matcher_t *
1251 sdb_store_isnull_matcher(sdb_store_expr_t *expr)
1252 {
1253 return M(sdb_object_create("isnull-matcher", isnull_type,
1254 MATCHER_ISNULL, expr));
1255 } /* sdb_store_isnull_matcher */
1257 sdb_store_matcher_t *
1258 sdb_store_isnnull_matcher(sdb_store_expr_t *expr)
1259 {
1260 return M(sdb_object_create("isnull-matcher", isnull_type,
1261 MATCHER_ISNNULL, expr));
1262 } /* sdb_store_isnnull_matcher */
1264 sdb_store_matcher_op_cb
1265 sdb_store_parse_matcher_op(const char *op)
1266 {
1267 if (! strcasecmp(op, "<"))
1268 return sdb_store_cmp_lt;
1269 else if (! strcasecmp(op, "<="))
1270 return sdb_store_cmp_le;
1271 else if (! strcasecmp(op, "="))
1272 return sdb_store_cmp_eq;
1273 else if (! strcasecmp(op, "!="))
1274 return sdb_store_cmp_ne;
1275 else if (! strcasecmp(op, ">="))
1276 return sdb_store_cmp_ge;
1277 else if (! strcasecmp(op, ">"))
1278 return sdb_store_cmp_gt;
1279 else if (! strcasecmp(op, "=~"))
1280 return sdb_store_regex_matcher;
1281 else if (! strcasecmp(op, "!~"))
1282 return sdb_store_nregex_matcher;
1283 return NULL;
1284 } /* sdb_store_parse_matcher_op */
1286 int
1287 sdb_store_parse_object_type_plural(const char *name)
1288 {
1289 if (! strcasecmp(name, "hosts"))
1290 return SDB_HOST;
1291 else if (! strcasecmp(name, "services"))
1292 return SDB_SERVICE;
1293 else if (! strcasecmp(name, "metrics"))
1294 return SDB_METRIC;
1295 return -1;
1296 } /* sdb_store_parse_object_type_plural */
1298 int
1299 sdb_store_parse_field_name(const char *name)
1300 {
1301 if (! strcasecmp(name, "name"))
1302 return SDB_FIELD_NAME;
1303 else if (! strcasecmp(name, "last_update"))
1304 return SDB_FIELD_LAST_UPDATE;
1305 else if (! strcasecmp(name, "age"))
1306 return SDB_FIELD_AGE;
1307 else if (! strcasecmp(name, "interval"))
1308 return SDB_FIELD_INTERVAL;
1309 else if (! strcasecmp(name, "backend"))
1310 return SDB_FIELD_BACKEND;
1311 return -1;
1312 } /* sdb_store_parse_field_name */
1314 static sdb_store_matcher_t *
1315 maybe_inv_matcher(sdb_store_matcher_t *m, _Bool inv)
1316 {
1317 sdb_store_matcher_t *tmp;
1319 if ((! m) || (! inv))
1320 return m;
1322 tmp = sdb_store_inv_matcher(m);
1323 /* pass ownership to the inverse matcher */
1324 sdb_object_deref(SDB_OBJ(m));
1325 return tmp;
1326 } /* maybe_inv_matcher */
1328 static int
1329 parse_cond_op(const char *op,
1330 sdb_store_matcher_t *(**matcher)(sdb_store_cond_t *), _Bool *inv)
1331 {
1332 *inv = 0;
1333 if (! strcasecmp(op, "<"))
1334 *matcher = sdb_store_lt_matcher;
1335 else if (! strcasecmp(op, "<="))
1336 *matcher = sdb_store_le_matcher;
1337 else if (! strcasecmp(op, "="))
1338 *matcher = sdb_store_eq_matcher;
1339 else if (! strcasecmp(op, ">="))
1340 *matcher = sdb_store_ge_matcher;
1341 else if (! strcasecmp(op, ">"))
1342 *matcher = sdb_store_gt_matcher;
1343 else if (! strcasecmp(op, "!=")) {
1344 *matcher = sdb_store_eq_matcher;
1345 *inv = 1;
1346 }
1347 else
1348 return -1;
1349 return 0;
1350 } /* parse_cond_op */
1352 static sdb_store_matcher_t *
1353 parse_attr_cmp(const char *attr, const char *op, sdb_store_expr_t *expr)
1354 {
1355 sdb_store_matcher_t *(*matcher)(sdb_store_cond_t *) = NULL;
1356 sdb_store_matcher_t *m;
1357 sdb_store_cond_t *cond;
1358 _Bool inv = 0;
1360 if (! attr)
1361 return NULL;
1363 if (! expr)
1364 return NULL;
1365 else if (parse_cond_op(op, &matcher, &inv))
1366 return NULL;
1368 cond = sdb_store_attr_cond(attr, expr);
1369 if (! cond)
1370 return NULL;
1372 m = matcher(cond);
1373 /* pass ownership to 'm' or destroy in case of an error */
1374 sdb_object_deref(SDB_OBJ(cond));
1375 return maybe_inv_matcher(m, inv);
1376 } /* parse_attr_cmp */
1378 sdb_store_matcher_t *
1379 sdb_store_matcher_parse_cmp(const char *obj_type, const char *attr,
1380 const char *op, sdb_store_expr_t *expr)
1381 {
1382 int type = -1;
1383 _Bool inv = 0;
1384 _Bool re = 0;
1386 sdb_data_t value = SDB_DATA_INIT;
1387 sdb_store_matcher_t *m = NULL;
1389 if (! strcasecmp(obj_type, "host"))
1390 type = SDB_HOST;
1391 else if (! strcasecmp(obj_type, "service"))
1392 type = SDB_SERVICE;
1393 else if (! strcasecmp(obj_type, "metric"))
1394 type = SDB_METRIC;
1395 else if (! strcasecmp(obj_type, "attribute"))
1396 type = SDB_ATTRIBUTE;
1397 else
1398 return NULL;
1400 /* XXX: this code sucks! */
1401 if (! strcasecmp(op, "=")) {
1402 /* nothing to do */
1403 }
1404 else if (! strcasecmp(op, "!=")) {
1405 inv = 1;
1406 }
1407 else if (! strcasecmp(op, "=~")) {
1408 re = 1;
1409 }
1410 else if (! strcasecmp(op, "!~")) {
1411 inv = 1;
1412 re = 1;
1413 }
1414 else if (type == SDB_ATTRIBUTE)
1415 return parse_attr_cmp(attr, op, expr);
1416 else
1417 return NULL;
1419 if (! expr)
1420 return NULL;
1422 if (sdb_store_expr_eval(expr, /* obj */ NULL, &value, /* filter */ NULL)
1423 || (value.type != SDB_TYPE_STRING)) {
1424 sdb_data_free_datum(&value);
1425 if (type != SDB_ATTRIBUTE)
1426 return NULL;
1427 return parse_attr_cmp(attr, op, expr);
1428 }
1430 if (! attr)
1431 m = sdb_store_name_matcher(type, value.data.string, re);
1432 else if (type == SDB_ATTRIBUTE)
1433 m = sdb_store_attr_matcher(attr, value.data.string, re);
1435 sdb_data_free_datum(&value);
1436 return maybe_inv_matcher(m, inv);
1437 } /* sdb_store_matcher_parse_cmp */
1439 sdb_store_matcher_t *
1440 sdb_store_matcher_parse_field_cmp(const char *name, const char *op,
1441 sdb_store_expr_t *expr)
1442 {
1443 sdb_store_matcher_t *(*matcher)(sdb_store_cond_t *) = NULL;
1444 sdb_store_matcher_t *m;
1445 sdb_store_cond_t *cond;
1446 _Bool inv = 0;
1448 int field;
1450 if (! expr)
1451 return NULL;
1453 field = sdb_store_parse_field_name(name);
1454 if (field < 0)
1455 return NULL;
1457 if (parse_cond_op(op, &matcher, &inv))
1458 return NULL;
1459 cond = sdb_store_obj_cond(field, expr);
1460 if (! cond)
1461 return NULL;
1463 assert(matcher);
1464 m = matcher(cond);
1465 /* pass ownership to 'm' or destroy in case of an error */
1466 sdb_object_deref(SDB_OBJ(cond));
1467 return maybe_inv_matcher(m, inv);
1468 } /* sdb_store_matcher_parse_field_cmp */
1470 sdb_store_matcher_t *
1471 sdb_store_dis_matcher(sdb_store_matcher_t *left, sdb_store_matcher_t *right)
1472 {
1473 return M(sdb_object_create("dis-matcher", op_type, MATCHER_OR,
1474 left, right));
1475 } /* sdb_store_dis_matcher */
1477 sdb_store_matcher_t *
1478 sdb_store_con_matcher(sdb_store_matcher_t *left, sdb_store_matcher_t *right)
1479 {
1480 return M(sdb_object_create("con-matcher", op_type, MATCHER_AND,
1481 left, right));
1482 } /* sdb_store_con_matcher */
1484 sdb_store_matcher_t *
1485 sdb_store_inv_matcher(sdb_store_matcher_t *m)
1486 {
1487 return M(sdb_object_create("inv-matcher", uop_type, MATCHER_NOT, m));
1488 } /* sdb_store_inv_matcher */
1490 int
1491 sdb_store_matcher_matches(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
1492 sdb_store_matcher_t *filter)
1493 {
1494 if (filter && (! sdb_store_matcher_matches(filter, obj, NULL)))
1495 return 0;
1497 /* "NULL" always matches */
1498 if ((! m) || (! obj))
1499 return 1;
1501 if ((m->type < 0) || ((size_t)m->type >= SDB_STATIC_ARRAY_LEN(matchers)))
1502 return 0;
1504 return matchers[m->type](m, obj, filter);
1505 } /* sdb_store_matcher_matches */
1507 char *
1508 sdb_store_matcher_tostring(sdb_store_matcher_t *m, char *buf, size_t buflen)
1509 {
1510 if (! m)
1511 return NULL;
1513 if ((m->type < 0)
1514 || (((size_t)m->type >= SDB_STATIC_ARRAY_LEN(matchers_tostring))))
1515 return NULL;
1516 return matchers_tostring[m->type](m, buf, buflen);
1517 } /* sdb_store_matcher_tostring */
1519 int
1520 sdb_store_scan(sdb_store_matcher_t *m, sdb_store_matcher_t *filter,
1521 sdb_store_lookup_cb cb, void *user_data)
1522 {
1523 scan_iter_data_t data = { m, filter, cb, user_data };
1525 if (! cb)
1526 return -1;
1527 return sdb_store_iterate(scan_iter, &data);
1528 } /* sdb_store_scan */
1530 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */