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 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;
 391
 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         }
 398
 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);
 405
 406         sdb_data_free_datum(&v1);
 407         sdb_data_free_datum(&v2);
 408         return status;
 409 } /* cmp_expr */
 410
 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 */
 420
 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 */
 430
 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 */
 440
 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 */
 450
 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 */
 460
 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 */
 470
 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;
 477
 478         assert(m->type == MATCHER_IN);
 479
 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;
 483
 484         if (status)
 485                 status = sdb_data_inarray(&value, &array);
 486
 487         sdb_data_free_datum(&value);
 488         sdb_data_free_datum(&array);
 489         return status;
 490 } /* match_in */
 491
 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;
 498
 499         regex_t regex;
 500         _Bool free_regex = 0;
 501
 502         assert((m->type == MATCHER_REGEX)
 503                         || (m->type == MATCHER_NREGEX));
 504
 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;
 512
 513                 if (sdb_store_expr_eval(CMP_M(m)->right, obj, &tmp, filter))
 514                         return 0;
 515
 516                 if (tmp.type != SDB_TYPE_STRING) {
 517                         sdb_data_free_datum(&tmp);
 518                         return 0;
 519                 }
 520
 521                 raw = tmp.data.string;
 522                 if (sdb_data_parse(raw, SDB_TYPE_REGEX, &tmp)) {
 523                         free(raw);
 524                         return 0;
 525                 }
 526
 527                 regex = tmp.data.re.regex;
 528                 free_regex = 1;
 529                 free(tmp.data.re.raw);
 530                 free(raw);
 531         }
 532
 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(&regex, value, 0, NULL, 0))
 540                         status = 1;
 541         }
 542
 543         if (free_regex)
 544                 regfree(&regex);
 545         sdb_data_free_datum(&v);
 546         if (m->type == MATCHER_NREGEX)
 547                 return !status;
 548         return status;
 549 } /* match_regex */
 550
 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;
 557
 558         assert((m->type == MATCHER_ISNULL) || (m->type == MATCHER_ISNNULL));
 559
 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;
 567
 568         sdb_data_free_datum(&v);
 569         if (m->type == MATCHER_ISNNULL)
 570                 return !status;
 571         return status;
 572 } /* match_isnull */
 573
 574 typedef int (*matcher_cb)(sdb_store_matcher_t *, sdb_store_obj_t *,
 575                 sdb_store_matcher_t *);
 576
 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 };
 606
 607 /*
 608  * private conditional types
 609  */
 610
 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 *);
 616
 617         if (! name)
 618                 return -1;
 619
 620         SDB_STORE_COND(obj)->cmp = attr_cmp;
 621
 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 */
 629
 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 */
 637
 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 };
 643
 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 *);
 649
 650         SDB_STORE_COND(obj)->cmp = obj_cmp;
 651
 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 */
 657
 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 */
 663
 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 };
 669
 670 /*
 671  * private matcher types
 672  */
 673
 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 *);
 680
 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 */
 695
 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 */
 706
 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 */
 715
 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 */
 722
 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 *);
 728
 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 */
 737
 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 */
 747
 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 *);
 753
 754         if (! cond)
 755                 return -1;
 756
 757         sdb_object_ref(SDB_OBJ(cond));
 758
 759         M(obj)->type = type;
 760         COND_M(obj)->cond = cond;
 761         return 0;
 762 } /* cond_matcher_init */
 763
 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 */
 769
 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;
 776
 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));
 781
 782         if ((! OP_M(obj)->left) || (! OP_M(obj)->right))
 783                 return -1;
 784         return 0;
 785 } /* op_matcher_init */
 786
 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 */
 795
 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 *);
 801
 802         if (! CHILD_M(obj)->m)
 803                 return -1;
 804
 805         sdb_object_ref(SDB_OBJ(CHILD_M(obj)->m));
 806         return 0;
 807 } /* child_matcher_init */
 808
 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 */
 814
 815 static int
 816 cmp_matcher_init(sdb_object_t *obj, va_list ap)
 817 {
 818         M(obj)->type = va_arg(ap, int);
 819
 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));
 824
 825         if ((! CMP_M(obj)->left) || (! CMP_M(obj)->right))
 826                 return -1;
 827         return 0;
 828 } /* cmp_matcher_init */
 829
 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 */
 836
 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;
 843
 844         UOP_M(obj)->op = va_arg(ap, sdb_store_matcher_t *);
 845         sdb_object_ref(SDB_OBJ(UOP_M(obj)->op));
 846
 847         if (! UOP_M(obj)->op)
 848                 return -1;
 849         return 0;
 850 } /* uop_matcher_init */
 851
 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 */
 858
 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;
 865
 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 */
 870
 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 */
 877
 878 static sdb_type_t name_type = {
 879         /* size = */ sizeof(name_matcher_t),
 880         /* init = */ name_matcher_init,
 881         /* destroy = */ name_matcher_destroy,
 882 };
 883
 884 static sdb_type_t attr_type = {
 885         /* size = */ sizeof(attr_matcher_t),
 886         /* init = */ attr_matcher_init,
 887         /* destroy = */ attr_matcher_destroy,
 888 };
 889
 890 static sdb_type_t cond_type = {
 891         /* size = */ sizeof(cond_matcher_t),
 892         /* init = */ cond_matcher_init,
 893         /* destroy = */ cond_matcher_destroy,
 894 };
 895
 896 static sdb_type_t op_type = {
 897         /* size = */ sizeof(op_matcher_t),
 898         /* init = */ op_matcher_init,
 899         /* destroy = */ op_matcher_destroy,
 900 };
 901
 902 static sdb_type_t uop_type = {
 903         /* size = */ sizeof(uop_matcher_t),
 904         /* init = */ uop_matcher_init,
 905         /* destroy = */ uop_matcher_destroy,
 906 };
 907
 908 static sdb_type_t child_type = {
 909         /* size = */ sizeof(child_matcher_t),
 910         /* init = */ child_matcher_init,
 911         /* destroy = */ child_matcher_destroy,
 912 };
 913
 914 static sdb_type_t cmp_type = {
 915         /* size = */ sizeof(cmp_matcher_t),
 916         /* init = */ cmp_matcher_init,
 917         /* destroy = */ cmp_matcher_destroy,
 918 };
 919
 920 static sdb_type_t isnull_type = {
 921         /* size = */ sizeof(isnull_matcher_t),
 922         /* init = */ isnull_matcher_init,
 923         /* destroy = */ isnull_matcher_destroy,
 924 };
 925
 926 /*
 927  * public API
 928  */
 929
 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 */
 936
 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 */
 943
 944 sdb_store_matcher_t *
 945 sdb_store_name_matcher(int type, const char *name, _Bool re)
 946 {
 947         sdb_store_matcher_t *m;
 948
 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));
 953
 954         if (! m)
 955                 return NULL;
 956
 957         NAME_M(m)->obj_type = type;
 958         return m;
 959 } /* sdb_store_name_matcher */
 960
 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;
 965
 966         if (! name)
 967                 return NULL;
 968
 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 */
 977
 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 */
 991
 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 */
 998
 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 */
1005
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 */
1012
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 */
1019
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 */
1026
1027 /*
1028  * TODO: Rename sdb_store_cmp_* to sdb_store_* once the old code is unused and
1029  * has been removed.
1030  */
1031
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 */
1038
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 */
1045
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 */
1052
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 */
1059
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 */
1066
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 */
1073
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 */
1080
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;
1088
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 */
1099
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 */
1109
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 */
1116
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 */
1123
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 */
1145
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 */
1157
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 */
1173
1174 static sdb_store_matcher_t *
1175 maybe_inv_matcher(sdb_store_matcher_t *m, _Bool inv)
1176 {
1177         sdb_store_matcher_t *tmp;
1178
1179         if ((! m) || (! inv))
1180                 return m;
1181
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 */
1187
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 */
1211
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;
1219
1220         if (! attr)
1221                 return NULL;
1222
1223         if (! expr)
1224                 return NULL;
1225         else if (parse_cond_op(op, &matcher, &inv))
1226                 return NULL;
1227
1228         cond = sdb_store_attr_cond(attr, expr);
1229         if (! cond)
1230                 return NULL;
1231
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 */
1237
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;
1245
1246         sdb_data_t value = SDB_DATA_INIT;
1247         sdb_store_matcher_t *m = NULL;
1248
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;
1259
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;
1278
1279         if (! expr)
1280                 return NULL;
1281
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         }
1289
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);
1294
1295         sdb_data_free_datum(&value);
1296         return maybe_inv_matcher(m, inv);
1297 } /* sdb_store_matcher_parse_cmp */
1298
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;
1307
1308         int field;
1309
1310         if (! expr)
1311                 return NULL;
1312
1313         field = sdb_store_parse_field_name(name);
1314         if (field < 0)
1315                 return NULL;
1316
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;
1322
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 */
1329
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 */
1336
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 */
1343
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 */
1349
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;
1356
1357         /* "NULL" always matches */
1358         if ((! m) || (! obj))
1359                 return 1;
1360
1361         if ((m->type < 0) || ((size_t)m->type >= SDB_STATIC_ARRAY_LEN(matchers)))
1362                 return 0;
1363
1364         return matchers[m->type](m, obj, filter);
1365 } /* sdb_store_matcher_matches */
1366
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 };
1372
1373         if (! cb)
1374                 return -1;
1375         return sdb_store_iterate(scan_iter, &data);
1376 } /* sdb_store_scan */
1377
1378 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
1379