src/core/store_lookup.c

   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  */
  27
  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  */
  33
  34 #if HAVE_CONFIG_H
  35 #       include "config.h"
  36 #endif /* HAVE_CONFIG_H */
  37
  38 #include "sysdb.h"
  39 #include "core/store-private.h"
  40 #include "core/object.h"
  41
  42 #include <assert.h>
  43
  44 #include <sys/types.h>
  45 #include <regex.h>
  46
  47 #include <stdlib.h>
  48 #include <string.h>
  49
  50 #include <limits.h>
  51
  52 /*
  53  * private data types
  54  */
  55
  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;
  62
  63 /*
  64  * private helper functions
  65  */
  66
  67 static int
  68 scan_iter(sdb_store_obj_t *obj, void *user_data)
  69 {
  70         scan_iter_data_t *d = user_data;
  71
  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 */
  76
  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;
  82
  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));
  86
  87                 if (strcasecmp(name, SDB_OBJ(a)->name))
  88                         continue;
  89
  90                 assert(STORE_OBJ(a)->type == SDB_ATTRIBUTE);
  91                 attr = a;
  92                 break;
  93         }
  94         sdb_avltree_iter_destroy(iter);
  95
  96         if (filter && (! sdb_store_matcher_matches(filter, STORE_OBJ(attr),
  97                                         NULL)))
  98                 return NULL;
  99         return attr;
 100 } /* attr_get */
 101
 102 /*
 103  * conditional implementations
 104  */
 105
 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;
 113
 114         if (obj->type != SDB_HOST)
 115                 return INT_MAX;
 116
 117         if (sdb_store_expr_eval(ATTR_C(cond)->expr, obj, &value, filter))
 118                 return INT_MAX;
 119
 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 */
 130
 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;
 138
 139         if (sdb_store_expr_eval(OBJ_C(cond)->expr, obj, &value, filter))
 140                 return INT_MAX;
 141
 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;
 146
 147                 if (value.type != SDB_TYPE_STRING)
 148                         return INT_MAX;
 149
 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         }
 160
 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         }
 168
 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 */
 174
 175 /*
 176  * matcher implementations
 177  */
 178
 179 static int
 180 match_string(string_matcher_t *m, const char *name)
 181 {
 182         if ((! m->name) && (! m->name_re))
 183                 return 1;
 184
 185         if (! name)
 186                 name = "";
 187
 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 */
 195
 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;
 201
 202         assert((m->type == MATCHER_AND) || (m->type == MATCHER_OR));
 203         assert(OP_M(m)->left && OP_M(m)->right);
 204
 205         status = sdb_store_matcher_matches(OP_M(m)->left, obj, filter);
 206
 207         /* lazy evaluation */
 208         if ((! status) && (m->type == MATCHER_AND))
 209                 return status;
 210         else if (status && (m->type == MATCHER_OR))
 211                 return status;
 212
 213         return sdb_store_matcher_matches(OP_M(m)->right, obj, filter);
 214 } /* match_logical */
 215
 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);
 222
 223         return !sdb_store_matcher_matches(UOP_M(m)->op, obj, filter);
 224 } /* match_unary */
 225
 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;
 232
 233         assert(m->type == MATCHER_NAME);
 234
 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;
 239
 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         }
 251
 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 */
 265
 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;
 271
 272         assert(m->type == MATCHER_ATTR);
 273         assert(ATTR_M(m)->name);
 274
 275         if (obj->type != SDB_HOST)
 276                 return 0;
 277
 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 */
 288
 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;
 295
 296         assert((m->type == MATCHER_SERVICE)
 297                         || (m->type == MATCHER_METRIC)
 298                         || (m->type == MATCHER_ATTRIBUTE));
 299
 300         /* TODO: support all object types */
 301         if (obj->type != SDB_HOST)
 302                 return 0;
 303
 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);
 310
 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;
 316
 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 */
 325
 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 */
 335
 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 */
 345
 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 */
 355
 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 */
 365
 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 */
 375
 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;
 390
 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         }
 397
 398         if (v1.type == v2.type)
 399                 status = sdb_data_cmp(&v1, &v2);
 400         else
 401                 status = sdb_data_strcmp(&v1, &v2);
 402
 403         sdb_data_free_datum(&v1);
 404         sdb_data_free_datum(&v2);
 405         return status;
 406 } /* cmp_expr */
 407
 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 */
 417
 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 */
 427
 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 */
 437
 438 static int
 439 match_cmp_ge(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_GE);
 444         status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter);
 445         return (status != INT_MAX) && (status >= 0);
 446 } /* match_cmp_ge */
 447
 448 static int
 449 match_cmp_gt(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_GT);
 454         status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter);
 455         return (status != INT_MAX) && (status > 0);
 456 } /* match_cmp_gt */
 457
 458 static int
 459 match_regex(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
 460                 sdb_store_matcher_t *filter)
 461 {
 462         sdb_data_t v = SDB_DATA_INIT;
 463         int status = 0;
 464
 465         regex_t regex;
 466         _Bool free_regex = 0;
 467
 468         assert(m->type == MATCHER_REGEX);
 469
 470         if (! CMP_M(m)->right->type) {
 471                 assert(CMP_M(m)->right->data.type == SDB_TYPE_REGEX);
 472                 regex = CMP_M(m)->right->data.data.re.regex;
 473         }
 474         else {
 475                 sdb_data_t tmp = SDB_DATA_INIT;
 476                 char *raw;
 477
 478                 if (sdb_store_expr_eval(CMP_M(m)->right, obj, &tmp, filter))
 479                         return 0;
 480
 481                 if (tmp.type != SDB_TYPE_STRING) {
 482                         sdb_data_free_datum(&tmp);
 483                         return 0;
 484                 }
 485
 486                 raw = tmp.data.string;
 487                 if (sdb_data_parse(raw, SDB_TYPE_REGEX, &tmp)) {
 488                         free(raw);
 489                         return 0;
 490                 }
 491
 492                 regex = tmp.data.re.regex;
 493                 free_regex = 1;
 494                 free(tmp.data.re.raw);
 495                 free(raw);
 496         }
 497
 498         if (sdb_store_expr_eval(CMP_M(m)->left, obj, &v, filter))
 499                 status = 0;
 500         else {
 501                 char value[sdb_data_strlen(&v) + 1];
 502                 if (sdb_data_format(&v, value, sizeof(value), SDB_UNQUOTED) < 0)
 503                         status = 0;
 504                 else if (! regexec(&regex, value, 0, NULL, 0))
 505                         status = 1;
 506         }
 507
 508         if (free_regex)
 509                 regfree(&regex);
 510         sdb_data_free_datum(&v);
 511         return status;
 512 } /* match_regex */
 513
 514 static int
 515 match_isnull(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
 516                 sdb_store_matcher_t *filter)
 517 {
 518         assert(m->type == MATCHER_ISNULL);
 519         if (obj->type != SDB_HOST)
 520                 return 0;
 521         return attr_get(HOST(obj), ISNULL_M(m)->attr_name, filter) == NULL;
 522 } /* match_isnull */
 523
 524 typedef int (*matcher_cb)(sdb_store_matcher_t *, sdb_store_obj_t *,
 525                 sdb_store_matcher_t *);
 526
 527 /* this array needs to be indexable by the matcher types;
 528  * -> update the enum in store-private.h when updating this */
 529 static matcher_cb
 530 matchers[] = {
 531         match_logical,
 532         match_logical,
 533         match_unary,
 534         match_name,
 535         match_attr,
 536         match_child,
 537         match_child,
 538         match_child,
 539         match_lt,
 540         match_le,
 541         match_eq,
 542         match_ge,
 543         match_gt,
 544         match_cmp_lt,
 545         match_cmp_le,
 546         match_cmp_eq,
 547         match_cmp_ge,
 548         match_cmp_gt,
 549         match_regex,
 550         match_isnull,
 551 };
 552
 553 /*
 554  * private conditional types
 555  */
 556
 557 static int
 558 attr_cond_init(sdb_object_t *obj, va_list ap)
 559 {
 560         const char *name = va_arg(ap, const char *);
 561         sdb_store_expr_t *expr = va_arg(ap, sdb_store_expr_t *);
 562
 563         if (! name)
 564                 return -1;
 565
 566         SDB_STORE_COND(obj)->cmp = attr_cmp;
 567
 568         ATTR_C(obj)->name = strdup(name);
 569         if (! ATTR_C(obj)->name)
 570                 return -1;
 571         ATTR_C(obj)->expr = expr;
 572         sdb_object_ref(SDB_OBJ(expr));
 573         return 0;
 574 } /* attr_cond_init */
 575
 576 static void
 577 attr_cond_destroy(sdb_object_t *obj)
 578 {
 579         if (ATTR_C(obj)->name)
 580                 free(ATTR_C(obj)->name);
 581         sdb_object_deref(SDB_OBJ(ATTR_C(obj)->expr));
 582 } /* attr_cond_destroy */
 583
 584 static sdb_type_t attr_cond_type = {
 585         /* size = */ sizeof(attr_cond_t),
 586         /* init = */ attr_cond_init,
 587         /* destroy = */ attr_cond_destroy,
 588 };
 589
 590 static int
 591 obj_cond_init(sdb_object_t *obj, va_list ap)
 592 {
 593         int field = va_arg(ap, int);
 594         sdb_store_expr_t *expr = va_arg(ap, sdb_store_expr_t *);
 595
 596         SDB_STORE_COND(obj)->cmp = obj_cmp;
 597
 598         OBJ_C(obj)->field = field;
 599         OBJ_C(obj)->expr = expr;
 600         sdb_object_ref(SDB_OBJ(expr));
 601         return 0;
 602 } /* obj_cond_init */
 603
 604 static void
 605 obj_cond_destroy(sdb_object_t *obj)
 606 {
 607         sdb_object_deref(SDB_OBJ(OBJ_C(obj)->expr));
 608 } /* obj_cond_destroy */
 609
 610 static sdb_type_t obj_cond_type = {
 611         /* size = */ sizeof(obj_cond_t),
 612         /* init = */ obj_cond_init,
 613         /* destroy = */ obj_cond_destroy,
 614 };
 615
 616 /*
 617  * private matcher types
 618  */
 619
 620 /* initializes a string matcher consuming two elements from ap */
 621 static int
 622 string_matcher_init(string_matcher_t *m, va_list ap)
 623 {
 624         const char *name = va_arg(ap, const char *);
 625         const char *name_re = va_arg(ap, const char *);
 626
 627         if (name) {
 628                 m->name = strdup(name);
 629                 if (! m->name)
 630                         return -1;
 631         }
 632         if (name_re) {
 633                 m->name_re = malloc(sizeof(*m->name_re));
 634                 if (! m->name_re)
 635                         return -1;
 636                 if (regcomp(m->name_re, name_re, REG_EXTENDED | REG_ICASE | REG_NOSUB))
 637                         return -1;
 638         }
 639         return 0;
 640 } /* string_matcher_init */
 641
 642 static void
 643 string_matcher_destroy(string_matcher_t *m)
 644 {
 645         if (m->name)
 646                 free(m->name);
 647         if (m->name_re) {
 648                 regfree(m->name_re);
 649                 free(m->name_re);
 650         }
 651 } /* string_matcher_destroy */
 652
 653 static char *
 654 string_tostring(string_matcher_t *m, char *buf, size_t buflen)
 655 {
 656         snprintf(buf, buflen, "{ %s%s%s, %p }",
 657                         m->name ? "'" : "", m->name ? m->name : "NULL", m->name ? "'" : "",
 658                         m->name_re);
 659         return buf;
 660 } /* string_tostring */
 661
 662 /* initializes a name matcher */
 663 static int
 664 name_matcher_init(sdb_object_t *obj, va_list ap)
 665 {
 666         name_matcher_t *m = NAME_M(obj);
 667         M(obj)->type = MATCHER_NAME;
 668         return string_matcher_init(&m->name, ap);
 669 } /* name_matcher_init */
 670
 671 static void
 672 name_matcher_destroy(sdb_object_t *obj)
 673 {
 674         name_matcher_t *m = NAME_M(obj);
 675         string_matcher_destroy(&m->name);
 676 } /* name_matcher_destroy */
 677
 678 static char *
 679 name_tostring(sdb_store_matcher_t *m, char *buf, size_t buflen)
 680 {
 681         char name[buflen + 1];
 682         assert(m->type == MATCHER_NAME);
 683         snprintf(buf, buflen, "OBJ[%s]{ NAME%s }",
 684                         SDB_STORE_TYPE_TO_NAME(NAME_M(m)->obj_type),
 685                         string_tostring(&NAME_M(m)->name, name, sizeof(name)));
 686         return buf;
 687 } /* name_tostring */
 688
 689 static int
 690 attr_matcher_init(sdb_object_t *obj, va_list ap)
 691 {
 692         attr_matcher_t *attr = ATTR_M(obj);
 693         const char *name = va_arg(ap, const char *);
 694
 695         M(obj)->type = MATCHER_ATTR;
 696         if (name) {
 697                 attr->name = strdup(name);
 698                 if (! attr->name)
 699                         return -1;
 700         }
 701         return string_matcher_init(&attr->value, ap);
 702 } /* attr_matcher_init */
 703
 704 static void
 705 attr_matcher_destroy(sdb_object_t *obj)
 706 {
 707         attr_matcher_t *attr = ATTR_M(obj);
 708         if (attr->name)
 709                 free(attr->name);
 710         attr->name = NULL;
 711         string_matcher_destroy(&attr->value);
 712 } /* attr_matcher_destroy */
 713
 714 static char *
 715 attr_tostring(sdb_store_matcher_t *m, char *buf, size_t buflen)
 716 {
 717         char value[buflen + 1];
 718
 719         if (! m) {
 720                 snprintf(buf, buflen, "ATTR{}");
 721                 return buf;
 722         }
 723
 724         assert(m->type == MATCHER_ATTR);
 725         snprintf(buf, buflen, "ATTR[%s]{ VALUE%s }", ATTR_M(m)->name,
 726                         string_tostring(&ATTR_M(m)->value, value, sizeof(value)));
 727         return buf;
 728 } /* attr_tostring */
 729
 730 static int
 731 cond_matcher_init(sdb_object_t *obj, va_list ap)
 732 {
 733         int type = va_arg(ap, int);
 734         sdb_store_cond_t *cond = va_arg(ap, sdb_store_cond_t *);
 735
 736         if (! cond)
 737                 return -1;
 738
 739         sdb_object_ref(SDB_OBJ(cond));
 740
 741         M(obj)->type = type;
 742         COND_M(obj)->cond = cond;
 743         return 0;
 744 } /* cond_matcher_init */
 745
 746 static void
 747 cond_matcher_destroy(sdb_object_t *obj)
 748 {
 749         sdb_object_deref(SDB_OBJ(COND_M(obj)->cond));
 750 } /* cond_matcher_destroy */
 751
 752 static char *
 753 cond_tostring(sdb_store_matcher_t *m, char *buf, size_t buflen)
 754 {
 755         const char *type, *id;
 756         sdb_data_t value = SDB_DATA_INIT;
 757         char value_str[buflen];
 758         sdb_store_expr_t *expr;
 759
 760         if (COND_M(m)->cond->cmp == attr_cmp) {
 761                 type = "ATTR";
 762                 id = ATTR_C(COND_M(m)->cond)->name;
 763                 expr = ATTR_C(COND_M(m)->cond)->expr;
 764         }
 765         else if (COND_M(m)->cond->cmp == obj_cmp) {
 766                 type = "OBJ";
 767                 id = SDB_FIELD_TO_NAME(OBJ_C(COND_M(m)->cond)->field);
 768                 expr = OBJ_C(COND_M(m)->cond)->expr;
 769         }
 770         else {
 771                 snprintf(buf, buflen, "<unknown>");
 772                 return buf;
 773         }
 774
 775         if (sdb_store_expr_eval(expr, /* obj */ NULL, &value, /* filter */ NULL))
 776                 snprintf(value_str, sizeof(value_str), "ERR");
 777         else if (sdb_data_format(&value, value_str, sizeof(value_str),
 778                                 SDB_SINGLE_QUOTED) < 0)
 779                 snprintf(value_str, sizeof(value_str), "ERR");
 780         snprintf(buf, buflen, "%s[%s]{ %s %s }", type, id,
 781                         MATCHER_SYM(m->type), value_str);
 782         sdb_data_free_datum(&value);
 783         return buf;
 784 } /* cond_tostring */
 785
 786 static int
 787 op_matcher_init(sdb_object_t *obj, va_list ap)
 788 {
 789         M(obj)->type = va_arg(ap, int);
 790         if ((M(obj)->type != MATCHER_OR) && (M(obj)->type != MATCHER_AND))
 791                 return -1;
 792
 793         OP_M(obj)->left = va_arg(ap, sdb_store_matcher_t *);
 794         sdb_object_ref(SDB_OBJ(OP_M(obj)->left));
 795         OP_M(obj)->right = va_arg(ap, sdb_store_matcher_t *);
 796         sdb_object_ref(SDB_OBJ(OP_M(obj)->right));
 797
 798         if ((! OP_M(obj)->left) || (! OP_M(obj)->right))
 799                 return -1;
 800         return 0;
 801 } /* op_matcher_init */
 802
 803 static void
 804 op_matcher_destroy(sdb_object_t *obj)
 805 {
 806         if (OP_M(obj)->left)
 807                 sdb_object_deref(SDB_OBJ(OP_M(obj)->left));
 808         if (OP_M(obj)->right)
 809                 sdb_object_deref(SDB_OBJ(OP_M(obj)->right));
 810 } /* op_matcher_destroy */
 811
 812 static char *
 813 op_tostring(sdb_store_matcher_t *m, char *buf, size_t buflen)
 814 {
 815         char left[buflen + 1], right[buflen + 1];
 816
 817         if (! m) {
 818                 /* this should not happen */
 819                 snprintf(buf, buflen, "()");
 820                 return buf;
 821         }
 822
 823         assert((m->type == MATCHER_OR) || (m->type == MATCHER_AND));
 824         snprintf(buf, buflen, "(%s, %s, %s)",
 825                         m->type == MATCHER_OR ? "OR" : "AND",
 826                         sdb_store_matcher_tostring(OP_M(m)->left, left, sizeof(left)),
 827                         sdb_store_matcher_tostring(OP_M(m)->right, right, sizeof(right)));
 828         return buf;
 829 } /* op_tostring */
 830
 831 static int
 832 child_matcher_init(sdb_object_t *obj, va_list ap)
 833 {
 834         M(obj)->type = va_arg(ap, int);
 835         CHILD_M(obj)->m = va_arg(ap, sdb_store_matcher_t *);
 836
 837         if (! CHILD_M(obj)->m)
 838                 return -1;
 839
 840         sdb_object_ref(SDB_OBJ(CHILD_M(obj)->m));
 841         return 0;
 842 } /* child_matcher_init */
 843
 844 static void
 845 child_matcher_destroy(sdb_object_t *obj)
 846 {
 847         sdb_object_deref(SDB_OBJ(CHILD_M(obj)->m));
 848 } /* child_matcher_destroy */
 849
 850 static char *
 851 child_tostring(sdb_store_matcher_t *m, char *buf, size_t buflen)
 852 {
 853         snprintf(buf, buflen, "%s:", MATCHER_SYM(m->type));
 854         buf[buflen - 1] = '\0';
 855         sdb_store_matcher_tostring(CHILD_M(m)->m,
 856                         buf + strlen(buf), buflen - strlen(buf));
 857         return buf;
 858 } /* child_tostring */
 859
 860 static int
 861 cmp_matcher_init(sdb_object_t *obj, va_list ap)
 862 {
 863         M(obj)->type = va_arg(ap, int);
 864
 865         CMP_M(obj)->left = va_arg(ap, sdb_store_expr_t *);
 866         sdb_object_ref(SDB_OBJ(CMP_M(obj)->left));
 867         CMP_M(obj)->right = va_arg(ap, sdb_store_expr_t *);
 868         sdb_object_ref(SDB_OBJ(CMP_M(obj)->right));
 869
 870         if ((! CMP_M(obj)->left) || (! CMP_M(obj)->right))
 871                 return -1;
 872         return 0;
 873 } /* cmp_matcher_init */
 874
 875 static void
 876 cmp_matcher_destroy(sdb_object_t *obj)
 877 {
 878         sdb_object_deref(SDB_OBJ(CMP_M(obj)->left));
 879         sdb_object_deref(SDB_OBJ(CMP_M(obj)->right));
 880 } /* cmp_matcher_destroy */
 881
 882 static char *
 883 cmp_tostring(sdb_store_matcher_t *m, char *buf, size_t buflen)
 884 {
 885         if (! m) {
 886                 /* this should not happen */
 887                 snprintf(buf, buflen, "()");
 888                 return buf;
 889         }
 890
 891         /* TODO */
 892         snprintf(buf, buflen, "CMP_MATCHER(%d)", m->type);
 893         return buf;
 894 } /* cmp_tostring */
 895
 896 static int
 897 uop_matcher_init(sdb_object_t *obj, va_list ap)
 898 {
 899         M(obj)->type = va_arg(ap, int);
 900         if (M(obj)->type != MATCHER_NOT)
 901                 return -1;
 902
 903         UOP_M(obj)->op = va_arg(ap, sdb_store_matcher_t *);
 904         sdb_object_ref(SDB_OBJ(UOP_M(obj)->op));
 905
 906         if (! UOP_M(obj)->op)
 907                 return -1;
 908         return 0;
 909 } /* uop_matcher_init */
 910
 911 static void
 912 uop_matcher_destroy(sdb_object_t *obj)
 913 {
 914         if (UOP_M(obj)->op)
 915                 sdb_object_deref(SDB_OBJ(UOP_M(obj)->op));
 916 } /* uop_matcher_destroy */
 917
 918 static char *
 919 uop_tostring(sdb_store_matcher_t *m, char *buf, size_t buflen)
 920 {
 921         char op[buflen + 1];
 922
 923         if (! m) {
 924                 /* this should not happen */
 925                 snprintf(buf, buflen, "()");
 926                 return buf;
 927         }
 928
 929         assert(m->type == MATCHER_NOT);
 930         snprintf(buf, buflen, "(NOT, %s)",
 931                         sdb_store_matcher_tostring(UOP_M(m)->op, op, sizeof(op)));
 932         return buf;
 933 } /* uop_tostring */
 934
 935 static int
 936 isnull_matcher_init(sdb_object_t *obj, va_list ap)
 937 {
 938         const char *name;
 939
 940         M(obj)->type = va_arg(ap, int);
 941         if (M(obj)->type != MATCHER_ISNULL)
 942                 return -1;
 943
 944         name = va_arg(ap, const char *);
 945         if (! name)
 946                 return -1;
 947         ISNULL_M(obj)->attr_name = strdup(name);
 948         if (! ISNULL_M(obj)->attr_name)
 949                 return -1;
 950         return 0;
 951 } /* isnull_matcher_init */
 952
 953 static void
 954 isnull_matcher_destroy(sdb_object_t *obj)
 955 {
 956         if (ISNULL_M(obj)->attr_name)
 957                 free(ISNULL_M(obj)->attr_name);
 958         ISNULL_M(obj)->attr_name = NULL;
 959 } /* isnull_matcher_destroy */
 960
 961 static char *
 962 isnull_tostring(sdb_store_matcher_t *m, char *buf, size_t buflen)
 963 {
 964         snprintf(buf, buflen, "(IS NULL, ATTR[%s])", ISNULL_M(m)->attr_name);
 965         return buf;
 966 } /* isnull_tostring */
 967
 968 static sdb_type_t name_type = {
 969         /* size = */ sizeof(name_matcher_t),
 970         /* init = */ name_matcher_init,
 971         /* destroy = */ name_matcher_destroy,
 972 };
 973
 974 static sdb_type_t attr_type = {
 975         /* size = */ sizeof(attr_matcher_t),
 976         /* init = */ attr_matcher_init,
 977         /* destroy = */ attr_matcher_destroy,
 978 };
 979
 980 static sdb_type_t cond_type = {
 981         /* size = */ sizeof(cond_matcher_t),
 982         /* init = */ cond_matcher_init,
 983         /* destroy = */ cond_matcher_destroy,
 984 };
 985
 986 static sdb_type_t op_type = {
 987         /* size = */ sizeof(op_matcher_t),
 988         /* init = */ op_matcher_init,
 989         /* destroy = */ op_matcher_destroy,
 990 };
 991
 992 static sdb_type_t uop_type = {
 993         /* size = */ sizeof(uop_matcher_t),
 994         /* init = */ uop_matcher_init,
 995         /* destroy = */ uop_matcher_destroy,
 996 };
 997
 998 static sdb_type_t child_type = {
 999         /* size = */ sizeof(child_matcher_t),
1000         /* init = */ child_matcher_init,
1001         /* destroy = */ child_matcher_destroy,
1002 };
1003
1004 static sdb_type_t cmp_type = {
1005         /* size = */ sizeof(cmp_matcher_t),
1006         /* init = */ cmp_matcher_init,
1007         /* destroy = */ cmp_matcher_destroy,
1008 };
1009
1010 static sdb_type_t isnull_type = {
1011         /* size = */ sizeof(isnull_matcher_t),
1012         /* init = */ isnull_matcher_init,
1013         /* destroy = */ isnull_matcher_destroy,
1014 };
1015
1016 typedef char *(*matcher_tostring_cb)(sdb_store_matcher_t *, char *, size_t);
1017
1018 /* this array needs to be indexable by the matcher types;
1019  * -> update the enum in store-private.h when updating this */
1020 static matcher_tostring_cb
1021 matchers_tostring[] = {
1022         op_tostring,
1023         op_tostring,
1024         uop_tostring,
1025         name_tostring,
1026         attr_tostring,
1027         child_tostring,
1028         child_tostring,
1029         child_tostring,
1030         cond_tostring,
1031         cond_tostring,
1032         cond_tostring,
1033         cond_tostring,
1034         cond_tostring,
1035         cmp_tostring,
1036         cmp_tostring,
1037         cmp_tostring,
1038         cmp_tostring,
1039         cmp_tostring,
1040         cmp_tostring,
1041         isnull_tostring,
1042 };
1043
1044 /*
1045  * public API
1046  */
1047
1048 sdb_store_cond_t *
1049 sdb_store_attr_cond(const char *name, sdb_store_expr_t *expr)
1050 {
1051         return SDB_STORE_COND(sdb_object_create("attr-cond", attr_cond_type,
1052                                 name, expr));
1053 } /* sdb_store_attr_cond */
1054
1055 sdb_store_cond_t *
1056 sdb_store_obj_cond(int field, sdb_store_expr_t *expr)
1057 {
1058         return SDB_STORE_COND(sdb_object_create("obj-cond", obj_cond_type,
1059                                 field, expr));
1060 } /* sdb_store_obj_cond */
1061
1062 sdb_store_matcher_t *
1063 sdb_store_name_matcher(int type, const char *name, _Bool re)
1064 {
1065         sdb_store_matcher_t *m;
1066
1067         if (re)
1068                 m = M(sdb_object_create("name-matcher", name_type, NULL, name));
1069         else
1070                 m = M(sdb_object_create("name-matcher", name_type, name, NULL));
1071
1072         if (! m)
1073                 return NULL;
1074
1075         NAME_M(m)->obj_type = type;
1076         return m;
1077 } /* sdb_store_name_matcher */
1078
1079 sdb_store_matcher_t *
1080 sdb_store_attr_matcher(const char *name, const char *value, _Bool re)
1081 {
1082         sdb_store_matcher_t *m;
1083
1084         if (! name)
1085                 return NULL;
1086
1087         if (re)
1088                 m = M(sdb_object_create("attr-matcher", attr_type,
1089                                         name, NULL, value));
1090         else
1091                 m = M(sdb_object_create("attr-matcher", attr_type,
1092                                         name, value, NULL));
1093         return m;
1094 } /* sdb_store_attr_matcher */
1095
1096 sdb_store_matcher_t *
1097 sdb_store_child_matcher(int type, sdb_store_matcher_t *m)
1098 {
1099         if (type == SDB_SERVICE)
1100                 type = MATCHER_SERVICE;
1101         else if (type == SDB_METRIC)
1102                 type = MATCHER_METRIC;
1103         else if (type == SDB_ATTRIBUTE)
1104                 type = MATCHER_ATTRIBUTE;
1105         else
1106                 return NULL;
1107         return M(sdb_object_create("any-matcher", child_type, type, m));
1108 } /* sdb_store_child_matcher */
1109
1110 sdb_store_matcher_t *
1111 sdb_store_lt_matcher(sdb_store_cond_t *cond)
1112 {
1113         return M(sdb_object_create("lt-matcher", cond_type,
1114                                 MATCHER_LT, cond));
1115 } /* sdb_store_lt_matcher */
1116
1117 sdb_store_matcher_t *
1118 sdb_store_le_matcher(sdb_store_cond_t *cond)
1119 {
1120         return M(sdb_object_create("le-matcher", cond_type,
1121                                 MATCHER_LE, cond));
1122 } /* sdb_store_le_matcher */
1123
1124 sdb_store_matcher_t *
1125 sdb_store_eq_matcher(sdb_store_cond_t *cond)
1126 {
1127         return M(sdb_object_create("eq-matcher", cond_type,
1128                                 MATCHER_EQ, cond));
1129 } /* sdb_store_eq_matcher */
1130
1131 sdb_store_matcher_t *
1132 sdb_store_ge_matcher(sdb_store_cond_t *cond)
1133 {
1134         return M(sdb_object_create("ge-matcher", cond_type,
1135                                 MATCHER_GE, cond));
1136 } /* sdb_store_ge_matcher */
1137
1138 sdb_store_matcher_t *
1139 sdb_store_gt_matcher(sdb_store_cond_t *cond)
1140 {
1141         return M(sdb_object_create("gt-matcher", cond_type,
1142                                 MATCHER_GT, cond));
1143 } /* sdb_store_gt_matcher */
1144
1145 /*
1146  * TODO: Rename sdb_store_cmp_* to sdb_store_* once the old code is unused and
1147  * has been removed.
1148  */
1149
1150 sdb_store_matcher_t *
1151 sdb_store_cmp_lt(sdb_store_expr_t *left, sdb_store_expr_t *right)
1152 {
1153         return M(sdb_object_create("lt-matcher", cmp_type,
1154                                 MATCHER_CMP_LT, left, right));
1155 } /* sdb_store_cmp_lt */
1156
1157 sdb_store_matcher_t *
1158 sdb_store_cmp_le(sdb_store_expr_t *left, sdb_store_expr_t *right)
1159 {
1160         return M(sdb_object_create("le-matcher", cmp_type,
1161                                 MATCHER_CMP_LE, left, right));
1162 } /* sdb_store_cmp_le */
1163
1164 sdb_store_matcher_t *
1165 sdb_store_cmp_eq(sdb_store_expr_t *left, sdb_store_expr_t *right)
1166 {
1167         return M(sdb_object_create("eq-matcher", cmp_type,
1168                                 MATCHER_CMP_EQ, left, right));
1169 } /* sdb_store_cmp_eq */
1170
1171 sdb_store_matcher_t *
1172 sdb_store_cmp_ge(sdb_store_expr_t *left, sdb_store_expr_t *right)
1173 {
1174         return M(sdb_object_create("ge-matcher", cmp_type,
1175                                 MATCHER_CMP_GE, left, right));
1176 } /* sdb_store_cmp_ge */
1177
1178 sdb_store_matcher_t *
1179 sdb_store_cmp_gt(sdb_store_expr_t *left, sdb_store_expr_t *right)
1180 {
1181         return M(sdb_object_create("gt-matcher", cmp_type,
1182                                 MATCHER_CMP_GT, left, right));
1183 } /* sdb_store_cmp_gt */
1184
1185 sdb_store_matcher_t *
1186 sdb_store_regex_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right)
1187 {
1188         if (! right->type) {
1189                 if ((right->data.type != SDB_TYPE_STRING)
1190                                 && (right->data.type != SDB_TYPE_REGEX))
1191                         return NULL;
1192
1193                 if (right->data.type == SDB_TYPE_STRING) {
1194                         char *raw = right->data.data.string;
1195                         if (sdb_data_parse(raw, SDB_TYPE_REGEX, &right->data))
1196                                 return NULL;
1197                         free(raw);
1198                 }
1199         }
1200         return M(sdb_object_create("regex-matcher", cmp_type,
1201                                 MATCHER_REGEX, left, right));
1202 } /* sdb_store_regex_matcher */
1203
1204 sdb_store_matcher_t *
1205 sdb_store_isnull_matcher(const char *attr_name)
1206 {
1207         return M(sdb_object_create("isnull-matcher", isnull_type,
1208                                 MATCHER_ISNULL, attr_name));
1209 } /* sdb_store_isnull_matcher */
1210
1211 int
1212 sdb_store_parse_object_type_plural(const char *name)
1213 {
1214         if (! strcasecmp(name, "hosts"))
1215                 return SDB_HOST;
1216         else if (! strcasecmp(name, "services"))
1217                 return SDB_SERVICE;
1218         else if (! strcasecmp(name, "metrics"))
1219                 return SDB_METRIC;
1220         return -1;
1221 } /* sdb_store_parse_object_type_plural */
1222
1223 int
1224 sdb_store_parse_field_name(const char *name)
1225 {
1226         if (! strcasecmp(name, "name"))
1227                 return SDB_FIELD_NAME;
1228         else if (! strcasecmp(name, "last_update"))
1229                 return SDB_FIELD_LAST_UPDATE;
1230         else if (! strcasecmp(name, "age"))
1231                 return SDB_FIELD_AGE;
1232         else if (! strcasecmp(name, "interval"))
1233                 return SDB_FIELD_INTERVAL;
1234         else if (! strcasecmp(name, "backend"))
1235                 return SDB_FIELD_BACKEND;
1236         return -1;
1237 } /* sdb_store_parse_field_name */
1238
1239 static sdb_store_matcher_t *
1240 maybe_inv_matcher(sdb_store_matcher_t *m, _Bool inv)
1241 {
1242         sdb_store_matcher_t *tmp;
1243
1244         if ((! m) || (! inv))
1245                 return m;
1246
1247         tmp = sdb_store_inv_matcher(m);
1248         /* pass ownership to the inverse matcher */
1249         sdb_object_deref(SDB_OBJ(m));
1250         return tmp;
1251 } /* maybe_inv_matcher */
1252
1253 static int
1254 parse_cond_op(const char *op,
1255                 sdb_store_matcher_t *(**matcher)(sdb_store_cond_t *), _Bool *inv)
1256 {
1257         *inv = 0;
1258         if (! strcasecmp(op, "<"))
1259                 *matcher = sdb_store_lt_matcher;
1260         else if (! strcasecmp(op, "<="))
1261                 *matcher = sdb_store_le_matcher;
1262         else if (! strcasecmp(op, "="))
1263                 *matcher = sdb_store_eq_matcher;
1264         else if (! strcasecmp(op, ">="))
1265                 *matcher = sdb_store_ge_matcher;
1266         else if (! strcasecmp(op, ">"))
1267                 *matcher = sdb_store_gt_matcher;
1268         else if (! strcasecmp(op, "!=")) {
1269                 *matcher = sdb_store_eq_matcher;
1270                 *inv = 1;
1271         }
1272         else
1273                 return -1;
1274         return 0;
1275 } /* parse_cond_op */
1276
1277 static sdb_store_matcher_t *
1278 parse_attr_cmp(const char *attr, const char *op, sdb_store_expr_t *expr)
1279 {
1280         sdb_store_matcher_t *(*matcher)(sdb_store_cond_t *) = NULL;
1281         sdb_store_matcher_t *m;
1282         sdb_store_cond_t *cond;
1283         _Bool inv = 0;
1284
1285         if (! attr)
1286                 return NULL;
1287
1288         if (! strcasecmp(op, "IS")) {
1289                 if (! expr)
1290                         return sdb_store_isnull_matcher(attr);
1291                 else
1292                         return NULL;
1293         }
1294         else if (! expr)
1295                 return NULL;
1296         else if (parse_cond_op(op, &matcher, &inv))
1297                 return NULL;
1298
1299         cond = sdb_store_attr_cond(attr, expr);
1300         if (! cond)
1301                 return NULL;
1302
1303         m = matcher(cond);
1304         /* pass ownership to 'm' or destroy in case of an error */
1305         sdb_object_deref(SDB_OBJ(cond));
1306         return maybe_inv_matcher(m, inv);
1307 } /* parse_attr_cmp */
1308
1309 sdb_store_matcher_t *
1310 sdb_store_matcher_parse_cmp(const char *obj_type, const char *attr,
1311                 const char *op, sdb_store_expr_t *expr)
1312 {
1313         int type = -1;
1314         _Bool inv = 0;
1315         _Bool re = 0;
1316
1317         sdb_data_t value = SDB_DATA_INIT;
1318         sdb_store_matcher_t *m = NULL;
1319
1320         if (! strcasecmp(obj_type, "host"))
1321                 type = SDB_HOST;
1322         else if (! strcasecmp(obj_type, "service"))
1323                 type = SDB_SERVICE;
1324         else if (! strcasecmp(obj_type, "metric"))
1325                 type = SDB_METRIC;
1326         else if (! strcasecmp(obj_type, "attribute"))
1327                 type = SDB_ATTRIBUTE;
1328         else
1329                 return NULL;
1330
1331         /* XXX: this code sucks! */
1332         if (! strcasecmp(op, "=")) {
1333                 /* nothing to do */
1334         }
1335         else if (! strcasecmp(op, "!=")) {
1336                 inv = 1;
1337         }
1338         else if (! strcasecmp(op, "=~")) {
1339                 re = 1;
1340         }
1341         else if (! strcasecmp(op, "!~")) {
1342                 inv = 1;
1343                 re = 1;
1344         }
1345         else if (type == SDB_ATTRIBUTE)
1346                 return parse_attr_cmp(attr, op, expr);
1347         else
1348                 return NULL;
1349
1350         if (! expr)
1351                 return NULL;
1352
1353         if (sdb_store_expr_eval(expr, /* obj */ NULL, &value, /* filter */ NULL)
1354                         || (value.type != SDB_TYPE_STRING)) {
1355                 sdb_data_free_datum(&value);
1356                 if (type != SDB_ATTRIBUTE)
1357                         return NULL;
1358                 return parse_attr_cmp(attr, op, expr);
1359         }
1360
1361         if (! attr)
1362                 m = sdb_store_name_matcher(type, value.data.string, re);
1363         else if (type == SDB_ATTRIBUTE)
1364                 m = sdb_store_attr_matcher(attr, value.data.string, re);
1365
1366         sdb_data_free_datum(&value);
1367         return maybe_inv_matcher(m, inv);
1368 } /* sdb_store_matcher_parse_cmp */
1369
1370 sdb_store_matcher_t *
1371 sdb_store_matcher_parse_field_cmp(const char *name, const char *op,
1372                 sdb_store_expr_t *expr)
1373 {
1374         sdb_store_matcher_t *(*matcher)(sdb_store_cond_t *) = NULL;
1375         sdb_store_matcher_t *m;
1376         sdb_store_cond_t *cond;
1377         _Bool inv = 0;
1378
1379         int field;
1380
1381         if (! expr)
1382                 return NULL;
1383
1384         field = sdb_store_parse_field_name(name);
1385         if (field < 0)
1386                 return NULL;
1387
1388         if (parse_cond_op(op, &matcher, &inv))
1389                 return NULL;
1390         cond = sdb_store_obj_cond(field, expr);
1391         if (! cond)
1392                 return NULL;
1393
1394         assert(matcher);
1395         m = matcher(cond);
1396         /* pass ownership to 'm' or destroy in case of an error */
1397         sdb_object_deref(SDB_OBJ(cond));
1398         return maybe_inv_matcher(m, inv);
1399 } /* sdb_store_matcher_parse_field_cmp */
1400
1401 sdb_store_matcher_t *
1402 sdb_store_dis_matcher(sdb_store_matcher_t *left, sdb_store_matcher_t *right)
1403 {
1404         return M(sdb_object_create("dis-matcher", op_type, MATCHER_OR,
1405                                 left, right));
1406 } /* sdb_store_dis_matcher */
1407
1408 sdb_store_matcher_t *
1409 sdb_store_con_matcher(sdb_store_matcher_t *left, sdb_store_matcher_t *right)
1410 {
1411         return M(sdb_object_create("con-matcher", op_type, MATCHER_AND,
1412                                 left, right));
1413 } /* sdb_store_con_matcher */
1414
1415 sdb_store_matcher_t *
1416 sdb_store_inv_matcher(sdb_store_matcher_t *m)
1417 {
1418         return M(sdb_object_create("inv-matcher", uop_type, MATCHER_NOT, m));
1419 } /* sdb_store_inv_matcher */
1420
1421 int
1422 sdb_store_matcher_matches(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
1423                 sdb_store_matcher_t *filter)
1424 {
1425         if (filter && (! sdb_store_matcher_matches(filter, obj, NULL)))
1426                 return 0;
1427
1428         /* "NULL" always matches */
1429         if ((! m) || (! obj))
1430                 return 1;
1431
1432         if ((m->type < 0) || ((size_t)m->type >= SDB_STATIC_ARRAY_LEN(matchers)))
1433                 return 0;
1434
1435         return matchers[m->type](m, obj, filter);
1436 } /* sdb_store_matcher_matches */
1437
1438 char *
1439 sdb_store_matcher_tostring(sdb_store_matcher_t *m, char *buf, size_t buflen)
1440 {
1441         if (! m)
1442                 return NULL;
1443
1444         if ((m->type < 0)
1445                         || (((size_t)m->type >= SDB_STATIC_ARRAY_LEN(matchers_tostring))))
1446                 return NULL;
1447         return matchers_tostring[m->type](m, buf, buflen);
1448 } /* sdb_store_matcher_tostring */
1449
1450 int
1451 sdb_store_scan(sdb_store_matcher_t *m, sdb_store_matcher_t *filter,
1452                 sdb_store_lookup_cb cb, void *user_data)
1453 {
1454         scan_iter_data_t data = { m, filter, cb, user_data };
1455
1456         if (! cb)
1457                 return -1;
1458         return sdb_store_iterate(scan_iter, &data);
1459 } /* sdb_store_scan */
1460
1461 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
1462