f1baea644a4c2f2b2ee16e18ecc3d531f0e4f723
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 or if any of them
383 * evaluated to NULL.
384 */
385 static int
386 cmp_expr(sdb_store_expr_t *e1, sdb_store_expr_t *e2,
387 sdb_store_obj_t *obj, sdb_store_matcher_t *filter)
388 {
389 sdb_data_t v1 = SDB_DATA_INIT, v2 = SDB_DATA_INIT;
390 int status;
392 if (sdb_store_expr_eval(e1, obj, &v1, filter))
393 return INT_MAX;
394 if (sdb_store_expr_eval(e2, obj, &v2, filter)) {
395 sdb_data_free_datum(&v1);
396 return INT_MAX;
397 }
399 if (sdb_data_isnull(&v1) || (sdb_data_isnull(&v2)))
400 status = INT_MAX;
401 else if (v1.type == v2.type)
402 status = sdb_data_cmp(&v1, &v2);
403 else
404 status = sdb_data_strcmp(&v1, &v2);
406 sdb_data_free_datum(&v1);
407 sdb_data_free_datum(&v2);
408 return status;
409 } /* cmp_expr */
411 static int
412 match_cmp_lt(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
413 sdb_store_matcher_t *filter)
414 {
415 int status;
416 assert(m->type == MATCHER_CMP_LT);
417 status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter);
418 return (status != INT_MAX) && (status < 0);
419 } /* match_cmp_lt */
421 static int
422 match_cmp_le(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
423 sdb_store_matcher_t *filter)
424 {
425 int status;
426 assert(m->type == MATCHER_CMP_LE);
427 status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter);
428 return (status != INT_MAX) && (status <= 0);
429 } /* match_cmp_le */
431 static int
432 match_cmp_eq(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
433 sdb_store_matcher_t *filter)
434 {
435 int status;
436 assert(m->type == MATCHER_CMP_EQ);
437 status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter);
438 return (status != INT_MAX) && (! status);
439 } /* match_cmp_eq */
441 static int
442 match_cmp_ne(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
443 sdb_store_matcher_t *filter)
444 {
445 int status;
446 assert(m->type == MATCHER_CMP_NE);
447 status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter);
448 return (status != INT_MAX) && status;
449 } /* match_cmp_ne */
451 static int
452 match_cmp_ge(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
453 sdb_store_matcher_t *filter)
454 {
455 int status;
456 assert(m->type == MATCHER_CMP_GE);
457 status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter);
458 return (status != INT_MAX) && (status >= 0);
459 } /* match_cmp_ge */
461 static int
462 match_cmp_gt(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
463 sdb_store_matcher_t *filter)
464 {
465 int status;
466 assert(m->type == MATCHER_CMP_GT);
467 status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter);
468 return (status != INT_MAX) && (status > 0);
469 } /* match_cmp_gt */
471 static int
472 match_in(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
473 sdb_store_matcher_t *filter)
474 {
475 sdb_data_t value = SDB_DATA_INIT, array = SDB_DATA_INIT;
476 int status = 1;
478 assert(m->type == MATCHER_IN);
480 if ((sdb_store_expr_eval(CMP_M(m)->left, obj, &value, filter))
481 || (sdb_store_expr_eval(CMP_M(m)->right, obj, &array, filter)))
482 status = 0;
484 if (status)
485 status = sdb_data_inarray(&value, &array);
487 sdb_data_free_datum(&value);
488 sdb_data_free_datum(&array);
489 return status;
490 } /* match_in */
492 static int
493 match_regex(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
494 sdb_store_matcher_t *filter)
495 {
496 sdb_data_t v = SDB_DATA_INIT;
497 int status = 0;
499 regex_t regex;
500 _Bool free_regex = 0;
502 assert((m->type == MATCHER_REGEX)
503 || (m->type == MATCHER_NREGEX));
505 if (! CMP_M(m)->right->type) {
506 assert(CMP_M(m)->right->data.type == SDB_TYPE_REGEX);
507 regex = CMP_M(m)->right->data.data.re.regex;
508 }
509 else {
510 sdb_data_t tmp = SDB_DATA_INIT;
511 char *raw;
513 if (sdb_store_expr_eval(CMP_M(m)->right, obj, &tmp, filter))
514 return 0;
516 if (tmp.type != SDB_TYPE_STRING) {
517 sdb_data_free_datum(&tmp);
518 return 0;
519 }
521 raw = tmp.data.string;
522 if (sdb_data_parse(raw, SDB_TYPE_REGEX, &tmp)) {
523 free(raw);
524 return 0;
525 }
527 regex = tmp.data.re.regex;
528 free_regex = 1;
529 free(tmp.data.re.raw);
530 free(raw);
531 }
533 if (sdb_store_expr_eval(CMP_M(m)->left, obj, &v, filter))
534 status = 0;
535 else {
536 char value[sdb_data_strlen(&v) + 1];
537 if (sdb_data_format(&v, value, sizeof(value), SDB_UNQUOTED) < 0)
538 status = 0;
539 else if (! regexec(®ex, value, 0, NULL, 0))
540 status = 1;
541 }
543 if (free_regex)
544 regfree(®ex);
545 sdb_data_free_datum(&v);
546 if (m->type == MATCHER_NREGEX)
547 return !status;
548 return status;
549 } /* match_regex */
551 static int
552 match_isnull(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
553 sdb_store_matcher_t *filter)
554 {
555 sdb_data_t v = SDB_DATA_INIT;
556 int status;
558 assert((m->type == MATCHER_ISNULL) || (m->type == MATCHER_ISNNULL));
560 /* TODO: this might hide real errors;
561 * improve error reporting and propagation */
562 if (sdb_store_expr_eval(ISNULL_M(m)->expr, obj, &v, filter)
563 || sdb_data_isnull(&v))
564 status = 1;
565 else
566 status = 0;
568 sdb_data_free_datum(&v);
569 if (m->type == MATCHER_ISNNULL)
570 return !status;
571 return status;
572 } /* match_isnull */
574 typedef int (*matcher_cb)(sdb_store_matcher_t *, sdb_store_obj_t *,
575 sdb_store_matcher_t *);
577 /* this array needs to be indexable by the matcher types;
578 * -> update the enum in store-private.h when updating this */
579 static matcher_cb
580 matchers[] = {
581 match_logical,
582 match_logical,
583 match_unary,
584 match_name,
585 match_attr,
586 match_child,
587 match_child,
588 match_child,
589 match_lt,
590 match_le,
591 match_eq,
592 match_ge,
593 match_gt,
594 match_cmp_lt,
595 match_cmp_le,
596 match_cmp_eq,
597 match_cmp_ne,
598 match_cmp_ge,
599 match_cmp_gt,
600 match_in,
601 match_regex,
602 match_regex,
603 match_isnull,
604 match_isnull,
605 };
607 /*
608 * private conditional types
609 */
611 static int
612 attr_cond_init(sdb_object_t *obj, va_list ap)
613 {
614 const char *name = va_arg(ap, const char *);
615 sdb_store_expr_t *expr = va_arg(ap, sdb_store_expr_t *);
617 if (! name)
618 return -1;
620 SDB_STORE_COND(obj)->cmp = attr_cmp;
622 ATTR_C(obj)->name = strdup(name);
623 if (! ATTR_C(obj)->name)
624 return -1;
625 ATTR_C(obj)->expr = expr;
626 sdb_object_ref(SDB_OBJ(expr));
627 return 0;
628 } /* attr_cond_init */
630 static void
631 attr_cond_destroy(sdb_object_t *obj)
632 {
633 if (ATTR_C(obj)->name)
634 free(ATTR_C(obj)->name);
635 sdb_object_deref(SDB_OBJ(ATTR_C(obj)->expr));
636 } /* attr_cond_destroy */
638 static sdb_type_t attr_cond_type = {
639 /* size = */ sizeof(attr_cond_t),
640 /* init = */ attr_cond_init,
641 /* destroy = */ attr_cond_destroy,
642 };
644 static int
645 obj_cond_init(sdb_object_t *obj, va_list ap)
646 {
647 int field = va_arg(ap, int);
648 sdb_store_expr_t *expr = va_arg(ap, sdb_store_expr_t *);
650 SDB_STORE_COND(obj)->cmp = obj_cmp;
652 OBJ_C(obj)->field = field;
653 OBJ_C(obj)->expr = expr;
654 sdb_object_ref(SDB_OBJ(expr));
655 return 0;
656 } /* obj_cond_init */
658 static void
659 obj_cond_destroy(sdb_object_t *obj)
660 {
661 sdb_object_deref(SDB_OBJ(OBJ_C(obj)->expr));
662 } /* obj_cond_destroy */
664 static sdb_type_t obj_cond_type = {
665 /* size = */ sizeof(obj_cond_t),
666 /* init = */ obj_cond_init,
667 /* destroy = */ obj_cond_destroy,
668 };
670 /*
671 * private matcher types
672 */
674 /* initializes a string matcher consuming two elements from ap */
675 static int
676 string_matcher_init(string_matcher_t *m, va_list ap)
677 {
678 const char *name = va_arg(ap, const char *);
679 const char *name_re = va_arg(ap, const char *);
681 if (name) {
682 m->name = strdup(name);
683 if (! m->name)
684 return -1;
685 }
686 if (name_re) {
687 m->name_re = malloc(sizeof(*m->name_re));
688 if (! m->name_re)
689 return -1;
690 if (regcomp(m->name_re, name_re, REG_EXTENDED | REG_ICASE | REG_NOSUB))
691 return -1;
692 }
693 return 0;
694 } /* string_matcher_init */
696 static void
697 string_matcher_destroy(string_matcher_t *m)
698 {
699 if (m->name)
700 free(m->name);
701 if (m->name_re) {
702 regfree(m->name_re);
703 free(m->name_re);
704 }
705 } /* string_matcher_destroy */
707 /* initializes a name matcher */
708 static int
709 name_matcher_init(sdb_object_t *obj, va_list ap)
710 {
711 name_matcher_t *m = NAME_M(obj);
712 M(obj)->type = MATCHER_NAME;
713 return string_matcher_init(&m->name, ap);
714 } /* name_matcher_init */
716 static void
717 name_matcher_destroy(sdb_object_t *obj)
718 {
719 name_matcher_t *m = NAME_M(obj);
720 string_matcher_destroy(&m->name);
721 } /* name_matcher_destroy */
723 static int
724 attr_matcher_init(sdb_object_t *obj, va_list ap)
725 {
726 attr_matcher_t *attr = ATTR_M(obj);
727 const char *name = va_arg(ap, const char *);
729 M(obj)->type = MATCHER_ATTR;
730 if (name) {
731 attr->name = strdup(name);
732 if (! attr->name)
733 return -1;
734 }
735 return string_matcher_init(&attr->value, ap);
736 } /* attr_matcher_init */
738 static void
739 attr_matcher_destroy(sdb_object_t *obj)
740 {
741 attr_matcher_t *attr = ATTR_M(obj);
742 if (attr->name)
743 free(attr->name);
744 attr->name = NULL;
745 string_matcher_destroy(&attr->value);
746 } /* attr_matcher_destroy */
748 static int
749 cond_matcher_init(sdb_object_t *obj, va_list ap)
750 {
751 int type = va_arg(ap, int);
752 sdb_store_cond_t *cond = va_arg(ap, sdb_store_cond_t *);
754 if (! cond)
755 return -1;
757 sdb_object_ref(SDB_OBJ(cond));
759 M(obj)->type = type;
760 COND_M(obj)->cond = cond;
761 return 0;
762 } /* cond_matcher_init */
764 static void
765 cond_matcher_destroy(sdb_object_t *obj)
766 {
767 sdb_object_deref(SDB_OBJ(COND_M(obj)->cond));
768 } /* cond_matcher_destroy */
770 static int
771 op_matcher_init(sdb_object_t *obj, va_list ap)
772 {
773 M(obj)->type = va_arg(ap, int);
774 if ((M(obj)->type != MATCHER_OR) && (M(obj)->type != MATCHER_AND))
775 return -1;
777 OP_M(obj)->left = va_arg(ap, sdb_store_matcher_t *);
778 sdb_object_ref(SDB_OBJ(OP_M(obj)->left));
779 OP_M(obj)->right = va_arg(ap, sdb_store_matcher_t *);
780 sdb_object_ref(SDB_OBJ(OP_M(obj)->right));
782 if ((! OP_M(obj)->left) || (! OP_M(obj)->right))
783 return -1;
784 return 0;
785 } /* op_matcher_init */
787 static void
788 op_matcher_destroy(sdb_object_t *obj)
789 {
790 if (OP_M(obj)->left)
791 sdb_object_deref(SDB_OBJ(OP_M(obj)->left));
792 if (OP_M(obj)->right)
793 sdb_object_deref(SDB_OBJ(OP_M(obj)->right));
794 } /* op_matcher_destroy */
796 static int
797 child_matcher_init(sdb_object_t *obj, va_list ap)
798 {
799 M(obj)->type = va_arg(ap, int);
800 CHILD_M(obj)->m = va_arg(ap, sdb_store_matcher_t *);
802 if (! CHILD_M(obj)->m)
803 return -1;
805 sdb_object_ref(SDB_OBJ(CHILD_M(obj)->m));
806 return 0;
807 } /* child_matcher_init */
809 static void
810 child_matcher_destroy(sdb_object_t *obj)
811 {
812 sdb_object_deref(SDB_OBJ(CHILD_M(obj)->m));
813 } /* child_matcher_destroy */
815 static int
816 cmp_matcher_init(sdb_object_t *obj, va_list ap)
817 {
818 M(obj)->type = va_arg(ap, int);
820 CMP_M(obj)->left = va_arg(ap, sdb_store_expr_t *);
821 sdb_object_ref(SDB_OBJ(CMP_M(obj)->left));
822 CMP_M(obj)->right = va_arg(ap, sdb_store_expr_t *);
823 sdb_object_ref(SDB_OBJ(CMP_M(obj)->right));
825 if ((! CMP_M(obj)->left) || (! CMP_M(obj)->right))
826 return -1;
827 return 0;
828 } /* cmp_matcher_init */
830 static void
831 cmp_matcher_destroy(sdb_object_t *obj)
832 {
833 sdb_object_deref(SDB_OBJ(CMP_M(obj)->left));
834 sdb_object_deref(SDB_OBJ(CMP_M(obj)->right));
835 } /* cmp_matcher_destroy */
837 static int
838 uop_matcher_init(sdb_object_t *obj, va_list ap)
839 {
840 M(obj)->type = va_arg(ap, int);
841 if (M(obj)->type != MATCHER_NOT)
842 return -1;
844 UOP_M(obj)->op = va_arg(ap, sdb_store_matcher_t *);
845 sdb_object_ref(SDB_OBJ(UOP_M(obj)->op));
847 if (! UOP_M(obj)->op)
848 return -1;
849 return 0;
850 } /* uop_matcher_init */
852 static void
853 uop_matcher_destroy(sdb_object_t *obj)
854 {
855 if (UOP_M(obj)->op)
856 sdb_object_deref(SDB_OBJ(UOP_M(obj)->op));
857 } /* uop_matcher_destroy */
859 static int
860 isnull_matcher_init(sdb_object_t *obj, va_list ap)
861 {
862 M(obj)->type = va_arg(ap, int);
863 if ((M(obj)->type != MATCHER_ISNULL) && (M(obj)->type != MATCHER_ISNNULL))
864 return -1;
866 ISNULL_M(obj)->expr = va_arg(ap, sdb_store_expr_t *);
867 sdb_object_ref(SDB_OBJ(ISNULL_M(obj)->expr));
868 return 0;
869 } /* isnull_matcher_init */
871 static void
872 isnull_matcher_destroy(sdb_object_t *obj)
873 {
874 sdb_object_deref(SDB_OBJ(ISNULL_M(obj)->expr));
875 ISNULL_M(obj)->expr = NULL;
876 } /* isnull_matcher_destroy */
878 static sdb_type_t name_type = {
879 /* size = */ sizeof(name_matcher_t),
880 /* init = */ name_matcher_init,
881 /* destroy = */ name_matcher_destroy,
882 };
884 static sdb_type_t attr_type = {
885 /* size = */ sizeof(attr_matcher_t),
886 /* init = */ attr_matcher_init,
887 /* destroy = */ attr_matcher_destroy,
888 };
890 static sdb_type_t cond_type = {
891 /* size = */ sizeof(cond_matcher_t),
892 /* init = */ cond_matcher_init,
893 /* destroy = */ cond_matcher_destroy,
894 };
896 static sdb_type_t op_type = {
897 /* size = */ sizeof(op_matcher_t),
898 /* init = */ op_matcher_init,
899 /* destroy = */ op_matcher_destroy,
900 };
902 static sdb_type_t uop_type = {
903 /* size = */ sizeof(uop_matcher_t),
904 /* init = */ uop_matcher_init,
905 /* destroy = */ uop_matcher_destroy,
906 };
908 static sdb_type_t child_type = {
909 /* size = */ sizeof(child_matcher_t),
910 /* init = */ child_matcher_init,
911 /* destroy = */ child_matcher_destroy,
912 };
914 static sdb_type_t cmp_type = {
915 /* size = */ sizeof(cmp_matcher_t),
916 /* init = */ cmp_matcher_init,
917 /* destroy = */ cmp_matcher_destroy,
918 };
920 static sdb_type_t isnull_type = {
921 /* size = */ sizeof(isnull_matcher_t),
922 /* init = */ isnull_matcher_init,
923 /* destroy = */ isnull_matcher_destroy,
924 };
926 /*
927 * public API
928 */
930 sdb_store_cond_t *
931 sdb_store_attr_cond(const char *name, sdb_store_expr_t *expr)
932 {
933 return SDB_STORE_COND(sdb_object_create("attr-cond", attr_cond_type,
934 name, expr));
935 } /* sdb_store_attr_cond */
937 sdb_store_cond_t *
938 sdb_store_obj_cond(int field, sdb_store_expr_t *expr)
939 {
940 return SDB_STORE_COND(sdb_object_create("obj-cond", obj_cond_type,
941 field, expr));
942 } /* sdb_store_obj_cond */
944 sdb_store_matcher_t *
945 sdb_store_name_matcher(int type, const char *name, _Bool re)
946 {
947 sdb_store_matcher_t *m;
949 if (re)
950 m = M(sdb_object_create("name-matcher", name_type, NULL, name));
951 else
952 m = M(sdb_object_create("name-matcher", name_type, name, NULL));
954 if (! m)
955 return NULL;
957 NAME_M(m)->obj_type = type;
958 return m;
959 } /* sdb_store_name_matcher */
961 sdb_store_matcher_t *
962 sdb_store_attr_matcher(const char *name, const char *value, _Bool re)
963 {
964 sdb_store_matcher_t *m;
966 if (! name)
967 return NULL;
969 if (re)
970 m = M(sdb_object_create("attr-matcher", attr_type,
971 name, NULL, value));
972 else
973 m = M(sdb_object_create("attr-matcher", attr_type,
974 name, value, NULL));
975 return m;
976 } /* sdb_store_attr_matcher */
978 sdb_store_matcher_t *
979 sdb_store_child_matcher(int type, sdb_store_matcher_t *m)
980 {
981 if (type == SDB_SERVICE)
982 type = MATCHER_SERVICE;
983 else if (type == SDB_METRIC)
984 type = MATCHER_METRIC;
985 else if (type == SDB_ATTRIBUTE)
986 type = MATCHER_ATTRIBUTE;
987 else
988 return NULL;
989 return M(sdb_object_create("any-matcher", child_type, type, m));
990 } /* sdb_store_child_matcher */
992 sdb_store_matcher_t *
993 sdb_store_lt_matcher(sdb_store_cond_t *cond)
994 {
995 return M(sdb_object_create("lt-matcher", cond_type,
996 MATCHER_LT, cond));
997 } /* sdb_store_lt_matcher */
999 sdb_store_matcher_t *
1000 sdb_store_le_matcher(sdb_store_cond_t *cond)
1001 {
1002 return M(sdb_object_create("le-matcher", cond_type,
1003 MATCHER_LE, cond));
1004 } /* sdb_store_le_matcher */
1006 sdb_store_matcher_t *
1007 sdb_store_eq_matcher(sdb_store_cond_t *cond)
1008 {
1009 return M(sdb_object_create("eq-matcher", cond_type,
1010 MATCHER_EQ, cond));
1011 } /* sdb_store_eq_matcher */
1013 sdb_store_matcher_t *
1014 sdb_store_ge_matcher(sdb_store_cond_t *cond)
1015 {
1016 return M(sdb_object_create("ge-matcher", cond_type,
1017 MATCHER_GE, cond));
1018 } /* sdb_store_ge_matcher */
1020 sdb_store_matcher_t *
1021 sdb_store_gt_matcher(sdb_store_cond_t *cond)
1022 {
1023 return M(sdb_object_create("gt-matcher", cond_type,
1024 MATCHER_GT, cond));
1025 } /* sdb_store_gt_matcher */
1027 /*
1028 * TODO: Rename sdb_store_cmp_* to sdb_store_* once the old code is unused and
1029 * has been removed.
1030 */
1032 sdb_store_matcher_t *
1033 sdb_store_cmp_lt(sdb_store_expr_t *left, sdb_store_expr_t *right)
1034 {
1035 return M(sdb_object_create("lt-matcher", cmp_type,
1036 MATCHER_CMP_LT, left, right));
1037 } /* sdb_store_cmp_lt */
1039 sdb_store_matcher_t *
1040 sdb_store_cmp_le(sdb_store_expr_t *left, sdb_store_expr_t *right)
1041 {
1042 return M(sdb_object_create("le-matcher", cmp_type,
1043 MATCHER_CMP_LE, left, right));
1044 } /* sdb_store_cmp_le */
1046 sdb_store_matcher_t *
1047 sdb_store_cmp_eq(sdb_store_expr_t *left, sdb_store_expr_t *right)
1048 {
1049 return M(sdb_object_create("eq-matcher", cmp_type,
1050 MATCHER_CMP_EQ, left, right));
1051 } /* sdb_store_cmp_eq */
1053 sdb_store_matcher_t *
1054 sdb_store_cmp_ne(sdb_store_expr_t *left, sdb_store_expr_t *right)
1055 {
1056 return M(sdb_object_create("ne-matcher", cmp_type,
1057 MATCHER_CMP_NE, left, right));
1058 } /* sdb_store_cmp_ne */
1060 sdb_store_matcher_t *
1061 sdb_store_cmp_ge(sdb_store_expr_t *left, sdb_store_expr_t *right)
1062 {
1063 return M(sdb_object_create("ge-matcher", cmp_type,
1064 MATCHER_CMP_GE, left, right));
1065 } /* sdb_store_cmp_ge */
1067 sdb_store_matcher_t *
1068 sdb_store_cmp_gt(sdb_store_expr_t *left, sdb_store_expr_t *right)
1069 {
1070 return M(sdb_object_create("gt-matcher", cmp_type,
1071 MATCHER_CMP_GT, left, right));
1072 } /* sdb_store_cmp_gt */
1074 sdb_store_matcher_t *
1075 sdb_store_in_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right)
1076 {
1077 return M(sdb_object_create("in-matcher", cmp_type,
1078 MATCHER_IN, left, right));
1079 } /* sdb_store_in_matcher */
1081 sdb_store_matcher_t *
1082 sdb_store_regex_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right)
1083 {
1084 if (! right->type) {
1085 if ((right->data.type != SDB_TYPE_STRING)
1086 && (right->data.type != SDB_TYPE_REGEX))
1087 return NULL;
1089 if (right->data.type == SDB_TYPE_STRING) {
1090 char *raw = right->data.data.string;
1091 if (sdb_data_parse(raw, SDB_TYPE_REGEX, &right->data))
1092 return NULL;
1093 free(raw);
1094 }
1095 }
1096 return M(sdb_object_create("regex-matcher", cmp_type,
1097 MATCHER_REGEX, left, right));
1098 } /* sdb_store_regex_matcher */
1100 sdb_store_matcher_t *
1101 sdb_store_nregex_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right)
1102 {
1103 sdb_store_matcher_t *m = sdb_store_regex_matcher(left, right);
1104 if (! m)
1105 return NULL;
1106 m->type = MATCHER_NREGEX;
1107 return m;
1108 } /* sdb_store_nregex_matcher */
1110 sdb_store_matcher_t *
1111 sdb_store_isnull_matcher(sdb_store_expr_t *expr)
1112 {
1113 return M(sdb_object_create("isnull-matcher", isnull_type,
1114 MATCHER_ISNULL, expr));
1115 } /* sdb_store_isnull_matcher */
1117 sdb_store_matcher_t *
1118 sdb_store_isnnull_matcher(sdb_store_expr_t *expr)
1119 {
1120 return M(sdb_object_create("isnull-matcher", isnull_type,
1121 MATCHER_ISNNULL, expr));
1122 } /* sdb_store_isnnull_matcher */
1124 sdb_store_matcher_op_cb
1125 sdb_store_parse_matcher_op(const char *op)
1126 {
1127 if (! strcasecmp(op, "<"))
1128 return sdb_store_cmp_lt;
1129 else if (! strcasecmp(op, "<="))
1130 return sdb_store_cmp_le;
1131 else if (! strcasecmp(op, "="))
1132 return sdb_store_cmp_eq;
1133 else if (! strcasecmp(op, "!="))
1134 return sdb_store_cmp_ne;
1135 else if (! strcasecmp(op, ">="))
1136 return sdb_store_cmp_ge;
1137 else if (! strcasecmp(op, ">"))
1138 return sdb_store_cmp_gt;
1139 else if (! strcasecmp(op, "=~"))
1140 return sdb_store_regex_matcher;
1141 else if (! strcasecmp(op, "!~"))
1142 return sdb_store_nregex_matcher;
1143 return NULL;
1144 } /* sdb_store_parse_matcher_op */
1146 int
1147 sdb_store_parse_object_type_plural(const char *name)
1148 {
1149 if (! strcasecmp(name, "hosts"))
1150 return SDB_HOST;
1151 else if (! strcasecmp(name, "services"))
1152 return SDB_SERVICE;
1153 else if (! strcasecmp(name, "metrics"))
1154 return SDB_METRIC;
1155 return -1;
1156 } /* sdb_store_parse_object_type_plural */
1158 int
1159 sdb_store_parse_field_name(const char *name)
1160 {
1161 if (! strcasecmp(name, "name"))
1162 return SDB_FIELD_NAME;
1163 else if (! strcasecmp(name, "last_update"))
1164 return SDB_FIELD_LAST_UPDATE;
1165 else if (! strcasecmp(name, "age"))
1166 return SDB_FIELD_AGE;
1167 else if (! strcasecmp(name, "interval"))
1168 return SDB_FIELD_INTERVAL;
1169 else if (! strcasecmp(name, "backend"))
1170 return SDB_FIELD_BACKEND;
1171 return -1;
1172 } /* sdb_store_parse_field_name */
1174 static sdb_store_matcher_t *
1175 maybe_inv_matcher(sdb_store_matcher_t *m, _Bool inv)
1176 {
1177 sdb_store_matcher_t *tmp;
1179 if ((! m) || (! inv))
1180 return m;
1182 tmp = sdb_store_inv_matcher(m);
1183 /* pass ownership to the inverse matcher */
1184 sdb_object_deref(SDB_OBJ(m));
1185 return tmp;
1186 } /* maybe_inv_matcher */
1188 static int
1189 parse_cond_op(const char *op,
1190 sdb_store_matcher_t *(**matcher)(sdb_store_cond_t *), _Bool *inv)
1191 {
1192 *inv = 0;
1193 if (! strcasecmp(op, "<"))
1194 *matcher = sdb_store_lt_matcher;
1195 else if (! strcasecmp(op, "<="))
1196 *matcher = sdb_store_le_matcher;
1197 else if (! strcasecmp(op, "="))
1198 *matcher = sdb_store_eq_matcher;
1199 else if (! strcasecmp(op, ">="))
1200 *matcher = sdb_store_ge_matcher;
1201 else if (! strcasecmp(op, ">"))
1202 *matcher = sdb_store_gt_matcher;
1203 else if (! strcasecmp(op, "!=")) {
1204 *matcher = sdb_store_eq_matcher;
1205 *inv = 1;
1206 }
1207 else
1208 return -1;
1209 return 0;
1210 } /* parse_cond_op */
1212 static sdb_store_matcher_t *
1213 parse_attr_cmp(const char *attr, const char *op, sdb_store_expr_t *expr)
1214 {
1215 sdb_store_matcher_t *(*matcher)(sdb_store_cond_t *) = NULL;
1216 sdb_store_matcher_t *m;
1217 sdb_store_cond_t *cond;
1218 _Bool inv = 0;
1220 if (! attr)
1221 return NULL;
1223 if (! expr)
1224 return NULL;
1225 else if (parse_cond_op(op, &matcher, &inv))
1226 return NULL;
1228 cond = sdb_store_attr_cond(attr, expr);
1229 if (! cond)
1230 return NULL;
1232 m = matcher(cond);
1233 /* pass ownership to 'm' or destroy in case of an error */
1234 sdb_object_deref(SDB_OBJ(cond));
1235 return maybe_inv_matcher(m, inv);
1236 } /* parse_attr_cmp */
1238 sdb_store_matcher_t *
1239 sdb_store_matcher_parse_cmp(const char *obj_type, const char *attr,
1240 const char *op, sdb_store_expr_t *expr)
1241 {
1242 int type = -1;
1243 _Bool inv = 0;
1244 _Bool re = 0;
1246 sdb_data_t value = SDB_DATA_INIT;
1247 sdb_store_matcher_t *m = NULL;
1249 if (! strcasecmp(obj_type, "host"))
1250 type = SDB_HOST;
1251 else if (! strcasecmp(obj_type, "service"))
1252 type = SDB_SERVICE;
1253 else if (! strcasecmp(obj_type, "metric"))
1254 type = SDB_METRIC;
1255 else if (! strcasecmp(obj_type, "attribute"))
1256 type = SDB_ATTRIBUTE;
1257 else
1258 return NULL;
1260 /* XXX: this code sucks! */
1261 if (! strcasecmp(op, "=")) {
1262 /* nothing to do */
1263 }
1264 else if (! strcasecmp(op, "!=")) {
1265 inv = 1;
1266 }
1267 else if (! strcasecmp(op, "=~")) {
1268 re = 1;
1269 }
1270 else if (! strcasecmp(op, "!~")) {
1271 inv = 1;
1272 re = 1;
1273 }
1274 else if (type == SDB_ATTRIBUTE)
1275 return parse_attr_cmp(attr, op, expr);
1276 else
1277 return NULL;
1279 if (! expr)
1280 return NULL;
1282 if (sdb_store_expr_eval(expr, /* obj */ NULL, &value, /* filter */ NULL)
1283 || (value.type != SDB_TYPE_STRING)) {
1284 sdb_data_free_datum(&value);
1285 if (type != SDB_ATTRIBUTE)
1286 return NULL;
1287 return parse_attr_cmp(attr, op, expr);
1288 }
1290 if (! attr)
1291 m = sdb_store_name_matcher(type, value.data.string, re);
1292 else if (type == SDB_ATTRIBUTE)
1293 m = sdb_store_attr_matcher(attr, value.data.string, re);
1295 sdb_data_free_datum(&value);
1296 return maybe_inv_matcher(m, inv);
1297 } /* sdb_store_matcher_parse_cmp */
1299 sdb_store_matcher_t *
1300 sdb_store_matcher_parse_field_cmp(const char *name, const char *op,
1301 sdb_store_expr_t *expr)
1302 {
1303 sdb_store_matcher_t *(*matcher)(sdb_store_cond_t *) = NULL;
1304 sdb_store_matcher_t *m;
1305 sdb_store_cond_t *cond;
1306 _Bool inv = 0;
1308 int field;
1310 if (! expr)
1311 return NULL;
1313 field = sdb_store_parse_field_name(name);
1314 if (field < 0)
1315 return NULL;
1317 if (parse_cond_op(op, &matcher, &inv))
1318 return NULL;
1319 cond = sdb_store_obj_cond(field, expr);
1320 if (! cond)
1321 return NULL;
1323 assert(matcher);
1324 m = matcher(cond);
1325 /* pass ownership to 'm' or destroy in case of an error */
1326 sdb_object_deref(SDB_OBJ(cond));
1327 return maybe_inv_matcher(m, inv);
1328 } /* sdb_store_matcher_parse_field_cmp */
1330 sdb_store_matcher_t *
1331 sdb_store_dis_matcher(sdb_store_matcher_t *left, sdb_store_matcher_t *right)
1332 {
1333 return M(sdb_object_create("dis-matcher", op_type, MATCHER_OR,
1334 left, right));
1335 } /* sdb_store_dis_matcher */
1337 sdb_store_matcher_t *
1338 sdb_store_con_matcher(sdb_store_matcher_t *left, sdb_store_matcher_t *right)
1339 {
1340 return M(sdb_object_create("con-matcher", op_type, MATCHER_AND,
1341 left, right));
1342 } /* sdb_store_con_matcher */
1344 sdb_store_matcher_t *
1345 sdb_store_inv_matcher(sdb_store_matcher_t *m)
1346 {
1347 return M(sdb_object_create("inv-matcher", uop_type, MATCHER_NOT, m));
1348 } /* sdb_store_inv_matcher */
1350 int
1351 sdb_store_matcher_matches(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
1352 sdb_store_matcher_t *filter)
1353 {
1354 if (filter && (! sdb_store_matcher_matches(filter, obj, NULL)))
1355 return 0;
1357 /* "NULL" always matches */
1358 if ((! m) || (! obj))
1359 return 1;
1361 if ((m->type < 0) || ((size_t)m->type >= SDB_STATIC_ARRAY_LEN(matchers)))
1362 return 0;
1364 return matchers[m->type](m, obj, filter);
1365 } /* sdb_store_matcher_matches */
1367 int
1368 sdb_store_scan(sdb_store_matcher_t *m, sdb_store_matcher_t *filter,
1369 sdb_store_lookup_cb cb, void *user_data)
1370 {
1371 scan_iter_data_t data = { m, filter, cb, user_data };
1373 if (! cb)
1374 return -1;
1375 return sdb_store_iterate(scan_iter, &data);
1376 } /* sdb_store_scan */
1378 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */