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  * matcher implementations
 104  */
 105
 106 static int
 107 match_string(string_matcher_t *m, const char *name)
 108 {
 109         if ((! m->name) && (! m->name_re))
 110                 return 1;
 111
 112         if (! name)
 113                 name = "";
 114
 115         if (m->name && strcasecmp(m->name, name))
 116                 return 0;
 117         if (m->name_re && regexec(m->name_re, name,
 118                                         /* matches */ 0, NULL, /* flags = */ 0))
 119                 return 0;
 120         return 1;
 121 } /* match_string */
 122
 123 static int
 124 match_logical(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
 125                 sdb_store_matcher_t *filter)
 126 {
 127         int status;
 128
 129         assert((m->type == MATCHER_AND) || (m->type == MATCHER_OR));
 130         assert(OP_M(m)->left && OP_M(m)->right);
 131
 132         status = sdb_store_matcher_matches(OP_M(m)->left, obj, filter);
 133
 134         /* lazy evaluation */
 135         if ((! status) && (m->type == MATCHER_AND))
 136                 return status;
 137         else if (status && (m->type == MATCHER_OR))
 138                 return status;
 139
 140         return sdb_store_matcher_matches(OP_M(m)->right, obj, filter);
 141 } /* match_logical */
 142
 143 static int
 144 match_unary(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
 145                 sdb_store_matcher_t *filter)
 146 {
 147         assert(m->type == MATCHER_NOT);
 148         assert(UOP_M(m)->op);
 149
 150         return !sdb_store_matcher_matches(UOP_M(m)->op, obj, filter);
 151 } /* match_unary */
 152
 153 static int
 154 match_name(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
 155                 sdb_store_matcher_t *filter)
 156 {
 157         sdb_avltree_iter_t *iter = NULL;
 158         int status = 0;
 159
 160         assert(m->type == MATCHER_NAME);
 161
 162         if (obj->type == NAME_M(m)->obj_type)
 163                 return match_string(&NAME_M(m)->name, SDB_OBJ(obj)->name);
 164         else if (obj->type != SDB_HOST)
 165                 return 0;
 166
 167         switch (NAME_M(m)->obj_type) {
 168                 case SDB_SERVICE:
 169                         iter = sdb_avltree_get_iter(HOST(obj)->services);
 170                         break;
 171                 case SDB_METRIC:
 172                         iter = sdb_avltree_get_iter(HOST(obj)->metrics);
 173                         break;
 174                 case SDB_ATTRIBUTE:
 175                         iter = sdb_avltree_get_iter(HOST(obj)->attributes);
 176                         break;
 177         }
 178
 179         while (sdb_avltree_iter_has_next(iter)) {
 180                 sdb_object_t *child = sdb_avltree_iter_get_next(iter);
 181                 if (filter && (! sdb_store_matcher_matches(filter, STORE_OBJ(child),
 182                                                 NULL)))
 183                         continue;
 184                 if (match_string(&NAME_M(m)->name, child->name)) {
 185                         status = 1;
 186                         break;
 187                 }
 188         }
 189         sdb_avltree_iter_destroy(iter);
 190         return status;
 191 } /* match_name */
 192
 193 static int
 194 match_attr(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
 195                 sdb_store_matcher_t *filter)
 196 {
 197         sdb_attribute_t *attr;
 198
 199         assert(m->type == MATCHER_ATTR);
 200         assert(ATTR_M(m)->name);
 201
 202         if (obj->type != SDB_HOST)
 203                 return 0;
 204
 205         attr = attr_get(HOST(obj), ATTR_M(m)->name, filter);
 206         if (attr) {
 207                 char buf[sdb_data_strlen(&attr->value) + 1];
 208                 if (sdb_data_format(&attr->value, buf, sizeof(buf), SDB_UNQUOTED) <= 0)
 209                         return 0;
 210                 if (match_string(&ATTR_M(m)->value, buf))
 211                         return 1;
 212         }
 213         return 0;
 214 } /* match_attr */
 215
 216 static int
 217 match_child(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
 218                 sdb_store_matcher_t *filter)
 219 {
 220         sdb_avltree_iter_t *iter = NULL;
 221         int status = 0;
 222
 223         assert((m->type == MATCHER_SERVICE)
 224                         || (m->type == MATCHER_METRIC)
 225                         || (m->type == MATCHER_ATTRIBUTE));
 226
 227         /* TODO: support all object types */
 228         if (obj->type != SDB_HOST)
 229                 return 0;
 230
 231         if (m->type == MATCHER_SERVICE)
 232                 iter = sdb_avltree_get_iter(HOST(obj)->services);
 233         else if (m->type == MATCHER_METRIC)
 234                 iter = sdb_avltree_get_iter(HOST(obj)->metrics);
 235         else if (m->type == SDB_ATTRIBUTE)
 236                 iter = sdb_avltree_get_iter(HOST(obj)->attributes);
 237
 238         while (sdb_avltree_iter_has_next(iter)) {
 239                 sdb_object_t *child = sdb_avltree_iter_get_next(iter);
 240                 if (filter && (! sdb_store_matcher_matches(filter,
 241                                                 STORE_OBJ(child), NULL)))
 242                         continue;
 243
 244                 if (sdb_store_matcher_matches(CHILD_M(m)->m, obj, filter)) {
 245                         status = 1;
 246                         break;
 247                 }
 248         }
 249         sdb_avltree_iter_destroy(iter);
 250         return status;
 251 } /* match_child */
 252
 253 static int
 254 match_lt(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
 255                 sdb_store_matcher_t *filter)
 256 {
 257         int status;
 258         assert(m->type == MATCHER_LT);
 259         status = COND_M(m)->cond->cmp(obj, COND_M(m)->cond, filter);
 260         return (status != INT_MAX) && (status < 0);
 261 } /* match_lt */
 262
 263 static int
 264 match_le(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
 265                 sdb_store_matcher_t *filter)
 266 {
 267         int status;
 268         assert(m->type == MATCHER_LE);
 269         status = COND_M(m)->cond->cmp(obj, COND_M(m)->cond, filter);
 270         return (status != INT_MAX) && (status <= 0);
 271 } /* match_le */
 272
 273 static int
 274 match_eq(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
 275                 sdb_store_matcher_t *filter)
 276 {
 277         int status;
 278         assert(m->type == MATCHER_EQ);
 279         status = COND_M(m)->cond->cmp(obj, COND_M(m)->cond, filter);
 280         return (status != INT_MAX) && (! status);
 281 } /* match_eq */
 282
 283 static int
 284 match_ge(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
 285                 sdb_store_matcher_t *filter)
 286 {
 287         int status;
 288         assert(m->type == MATCHER_GE);
 289         status = COND_M(m)->cond->cmp(obj, COND_M(m)->cond, filter);
 290         return (status != INT_MAX) && (status >= 0);
 291 } /* match_ge */
 292
 293 static int
 294 match_gt(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
 295                 sdb_store_matcher_t *filter)
 296 {
 297         int status;
 298         assert(m->type == MATCHER_GT);
 299         status = COND_M(m)->cond->cmp(obj, COND_M(m)->cond, filter);
 300         return (status != INT_MAX) && (status > 0);
 301 } /* match_gt */
 302
 303 /*
 304  * cmp_expr:
 305  * Compare the values of two expressions when evaluating them using the
 306  * specified stored object and filter. Returns a value less than, equal to, or
 307  * greater than zero if the value of the first expression compares less than,
 308  * equal to, or greater than the value of the second expression. Returns
 309  * INT_MAX if any of the expressions could not be evaluated or if any of them
 310  * evaluated to NULL.
 311  */
 312 static int
 313 cmp_expr(sdb_store_expr_t *e1, sdb_store_expr_t *e2,
 314                 sdb_store_obj_t *obj, sdb_store_matcher_t *filter)
 315 {
 316         sdb_data_t v1 = SDB_DATA_INIT, v2 = SDB_DATA_INIT;
 317         int status;
 318
 319         if (sdb_store_expr_eval(e1, obj, &v1, filter))
 320                 return INT_MAX;
 321         if (sdb_store_expr_eval(e2, obj, &v2, filter)) {
 322                 sdb_data_free_datum(&v1);
 323                 return INT_MAX;
 324         }
 325
 326         if (sdb_data_isnull(&v1) || (sdb_data_isnull(&v2)))
 327                 status = INT_MAX;
 328         else if (v1.type == v2.type)
 329                 status = sdb_data_cmp(&v1, &v2);
 330         else
 331                 status = sdb_data_strcmp(&v1, &v2);
 332
 333         sdb_data_free_datum(&v1);
 334         sdb_data_free_datum(&v2);
 335         return status;
 336 } /* cmp_expr */
 337
 338 static int
 339 match_cmp_lt(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
 340                 sdb_store_matcher_t *filter)
 341 {
 342         int status;
 343         assert(m->type == MATCHER_CMP_LT);
 344         status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter);
 345         return (status != INT_MAX) && (status < 0);
 346 } /* match_cmp_lt */
 347
 348 static int
 349 match_cmp_le(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
 350                 sdb_store_matcher_t *filter)
 351 {
 352         int status;
 353         assert(m->type == MATCHER_CMP_LE);
 354         status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter);
 355         return (status != INT_MAX) && (status <= 0);
 356 } /* match_cmp_le */
 357
 358 static int
 359 match_cmp_eq(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
 360                 sdb_store_matcher_t *filter)
 361 {
 362         int status;
 363         assert(m->type == MATCHER_CMP_EQ);
 364         status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter);
 365         return (status != INT_MAX) && (! status);
 366 } /* match_cmp_eq */
 367
 368 static int
 369 match_cmp_ne(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
 370                 sdb_store_matcher_t *filter)
 371 {
 372         int status;
 373         assert(m->type == MATCHER_CMP_NE);
 374         status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter);
 375         return (status != INT_MAX) && status;
 376 } /* match_cmp_ne */
 377
 378 static int
 379 match_cmp_ge(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
 380                 sdb_store_matcher_t *filter)
 381 {
 382         int status;
 383         assert(m->type == MATCHER_CMP_GE);
 384         status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter);
 385         return (status != INT_MAX) && (status >= 0);
 386 } /* match_cmp_ge */
 387
 388 static int
 389 match_cmp_gt(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
 390                 sdb_store_matcher_t *filter)
 391 {
 392         int status;
 393         assert(m->type == MATCHER_CMP_GT);
 394         status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter);
 395         return (status != INT_MAX) && (status > 0);
 396 } /* match_cmp_gt */
 397
 398 static int
 399 match_in(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
 400                 sdb_store_matcher_t *filter)
 401 {
 402         sdb_data_t value = SDB_DATA_INIT, array = SDB_DATA_INIT;
 403         int status = 1;
 404
 405         assert(m->type == MATCHER_IN);
 406
 407         if ((sdb_store_expr_eval(CMP_M(m)->left, obj, &value, filter))
 408                         || (sdb_store_expr_eval(CMP_M(m)->right, obj, &array, filter)))
 409                 status = 0;
 410
 411         if (status)
 412                 status = sdb_data_inarray(&value, &array);
 413
 414         sdb_data_free_datum(&value);
 415         sdb_data_free_datum(&array);
 416         return status;
 417 } /* match_in */
 418
 419 static int
 420 match_regex(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
 421                 sdb_store_matcher_t *filter)
 422 {
 423         sdb_data_t v = SDB_DATA_INIT;
 424         int status = 0;
 425
 426         regex_t regex;
 427         _Bool free_regex = 0;
 428
 429         assert((m->type == MATCHER_REGEX)
 430                         || (m->type == MATCHER_NREGEX));
 431
 432         if (! CMP_M(m)->right->type) {
 433                 assert(CMP_M(m)->right->data.type == SDB_TYPE_REGEX);
 434                 regex = CMP_M(m)->right->data.data.re.regex;
 435         }
 436         else {
 437                 sdb_data_t tmp = SDB_DATA_INIT;
 438                 char *raw;
 439
 440                 if (sdb_store_expr_eval(CMP_M(m)->right, obj, &tmp, filter))
 441                         return 0;
 442
 443                 if (tmp.type != SDB_TYPE_STRING) {
 444                         sdb_data_free_datum(&tmp);
 445                         return 0;
 446                 }
 447
 448                 raw = tmp.data.string;
 449                 if (sdb_data_parse(raw, SDB_TYPE_REGEX, &tmp)) {
 450                         free(raw);
 451                         return 0;
 452                 }
 453
 454                 regex = tmp.data.re.regex;
 455                 free_regex = 1;
 456                 free(tmp.data.re.raw);
 457                 free(raw);
 458         }
 459
 460         if ((sdb_store_expr_eval(CMP_M(m)->left, obj, &v, filter))
 461                         || (sdb_data_isnull(&v)))
 462                 status = 0;
 463         else {
 464                 char value[sdb_data_strlen(&v) + 1];
 465                 if (sdb_data_format(&v, value, sizeof(value), SDB_UNQUOTED) < 0)
 466                         status = 0;
 467                 else if (! regexec(&regex, value, 0, NULL, 0))
 468                         status = 1;
 469         }
 470
 471         if (free_regex)
 472                 regfree(&regex);
 473         sdb_data_free_datum(&v);
 474         if (m->type == MATCHER_NREGEX)
 475                 return !status;
 476         return status;
 477 } /* match_regex */
 478
 479 static int
 480 match_isnull(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
 481                 sdb_store_matcher_t *filter)
 482 {
 483         sdb_data_t v = SDB_DATA_INIT;
 484         int status;
 485
 486         assert((m->type == MATCHER_ISNULL) || (m->type == MATCHER_ISNNULL));
 487
 488         /* TODO: this might hide real errors;
 489          * improve error reporting and propagation */
 490         if (sdb_store_expr_eval(ISNULL_M(m)->expr, obj, &v, filter)
 491                         || sdb_data_isnull(&v))
 492                 status = 1;
 493         else
 494                 status = 0;
 495
 496         sdb_data_free_datum(&v);
 497         if (m->type == MATCHER_ISNNULL)
 498                 return !status;
 499         return status;
 500 } /* match_isnull */
 501
 502 typedef int (*matcher_cb)(sdb_store_matcher_t *, sdb_store_obj_t *,
 503                 sdb_store_matcher_t *);
 504
 505 /* this array needs to be indexable by the matcher types;
 506  * -> update the enum in store-private.h when updating this */
 507 static matcher_cb
 508 matchers[] = {
 509         match_logical,
 510         match_logical,
 511         match_unary,
 512         match_name,
 513         match_attr,
 514         match_child,
 515         match_child,
 516         match_child,
 517         match_lt,
 518         match_le,
 519         match_eq,
 520         match_ge,
 521         match_gt,
 522         match_cmp_lt,
 523         match_cmp_le,
 524         match_cmp_eq,
 525         match_cmp_ne,
 526         match_cmp_ge,
 527         match_cmp_gt,
 528         match_in,
 529         match_regex,
 530         match_regex,
 531         match_isnull,
 532         match_isnull,
 533 };
 534
 535 /*
 536  * private matcher types
 537  */
 538
 539 /* initializes a string matcher consuming two elements from ap */
 540 static int
 541 string_matcher_init(string_matcher_t *m, va_list ap)
 542 {
 543         const char *name = va_arg(ap, const char *);
 544         const char *name_re = va_arg(ap, const char *);
 545
 546         if (name) {
 547                 m->name = strdup(name);
 548                 if (! m->name)
 549                         return -1;
 550         }
 551         if (name_re) {
 552                 m->name_re = malloc(sizeof(*m->name_re));
 553                 if (! m->name_re)
 554                         return -1;
 555                 if (regcomp(m->name_re, name_re, REG_EXTENDED | REG_ICASE | REG_NOSUB))
 556                         return -1;
 557         }
 558         return 0;
 559 } /* string_matcher_init */
 560
 561 static void
 562 string_matcher_destroy(string_matcher_t *m)
 563 {
 564         if (m->name)
 565                 free(m->name);
 566         if (m->name_re) {
 567                 regfree(m->name_re);
 568                 free(m->name_re);
 569         }
 570 } /* string_matcher_destroy */
 571
 572 /* initializes a name matcher */
 573 static int
 574 name_matcher_init(sdb_object_t *obj, va_list ap)
 575 {
 576         name_matcher_t *m = NAME_M(obj);
 577         M(obj)->type = MATCHER_NAME;
 578         return string_matcher_init(&m->name, ap);
 579 } /* name_matcher_init */
 580
 581 static void
 582 name_matcher_destroy(sdb_object_t *obj)
 583 {
 584         name_matcher_t *m = NAME_M(obj);
 585         string_matcher_destroy(&m->name);
 586 } /* name_matcher_destroy */
 587
 588 static int
 589 attr_matcher_init(sdb_object_t *obj, va_list ap)
 590 {
 591         attr_matcher_t *attr = ATTR_M(obj);
 592         const char *name = va_arg(ap, const char *);
 593
 594         M(obj)->type = MATCHER_ATTR;
 595         if (name) {
 596                 attr->name = strdup(name);
 597                 if (! attr->name)
 598                         return -1;
 599         }
 600         return string_matcher_init(&attr->value, ap);
 601 } /* attr_matcher_init */
 602
 603 static void
 604 attr_matcher_destroy(sdb_object_t *obj)
 605 {
 606         attr_matcher_t *attr = ATTR_M(obj);
 607         if (attr->name)
 608                 free(attr->name);
 609         attr->name = NULL;
 610         string_matcher_destroy(&attr->value);
 611 } /* attr_matcher_destroy */
 612
 613 static int
 614 cond_matcher_init(sdb_object_t *obj, va_list ap)
 615 {
 616         int type = va_arg(ap, int);
 617         sdb_store_cond_t *cond = va_arg(ap, sdb_store_cond_t *);
 618
 619         if (! cond)
 620                 return -1;
 621
 622         sdb_object_ref(SDB_OBJ(cond));
 623
 624         M(obj)->type = type;
 625         COND_M(obj)->cond = cond;
 626         return 0;
 627 } /* cond_matcher_init */
 628
 629 static void
 630 cond_matcher_destroy(sdb_object_t *obj)
 631 {
 632         sdb_object_deref(SDB_OBJ(COND_M(obj)->cond));
 633 } /* cond_matcher_destroy */
 634
 635 static int
 636 op_matcher_init(sdb_object_t *obj, va_list ap)
 637 {
 638         M(obj)->type = va_arg(ap, int);
 639         if ((M(obj)->type != MATCHER_OR) && (M(obj)->type != MATCHER_AND))
 640                 return -1;
 641
 642         OP_M(obj)->left = va_arg(ap, sdb_store_matcher_t *);
 643         sdb_object_ref(SDB_OBJ(OP_M(obj)->left));
 644         OP_M(obj)->right = va_arg(ap, sdb_store_matcher_t *);
 645         sdb_object_ref(SDB_OBJ(OP_M(obj)->right));
 646
 647         if ((! OP_M(obj)->left) || (! OP_M(obj)->right))
 648                 return -1;
 649         return 0;
 650 } /* op_matcher_init */
 651
 652 static void
 653 op_matcher_destroy(sdb_object_t *obj)
 654 {
 655         if (OP_M(obj)->left)
 656                 sdb_object_deref(SDB_OBJ(OP_M(obj)->left));
 657         if (OP_M(obj)->right)
 658                 sdb_object_deref(SDB_OBJ(OP_M(obj)->right));
 659 } /* op_matcher_destroy */
 660
 661 static int
 662 child_matcher_init(sdb_object_t *obj, va_list ap)
 663 {
 664         M(obj)->type = va_arg(ap, int);
 665         CHILD_M(obj)->m = va_arg(ap, sdb_store_matcher_t *);
 666
 667         if (! CHILD_M(obj)->m)
 668                 return -1;
 669
 670         sdb_object_ref(SDB_OBJ(CHILD_M(obj)->m));
 671         return 0;
 672 } /* child_matcher_init */
 673
 674 static void
 675 child_matcher_destroy(sdb_object_t *obj)
 676 {
 677         sdb_object_deref(SDB_OBJ(CHILD_M(obj)->m));
 678 } /* child_matcher_destroy */
 679
 680 static int
 681 cmp_matcher_init(sdb_object_t *obj, va_list ap)
 682 {
 683         M(obj)->type = va_arg(ap, int);
 684
 685         CMP_M(obj)->left = va_arg(ap, sdb_store_expr_t *);
 686         sdb_object_ref(SDB_OBJ(CMP_M(obj)->left));
 687         CMP_M(obj)->right = va_arg(ap, sdb_store_expr_t *);
 688         sdb_object_ref(SDB_OBJ(CMP_M(obj)->right));
 689
 690         if ((! CMP_M(obj)->left) || (! CMP_M(obj)->right))
 691                 return -1;
 692         return 0;
 693 } /* cmp_matcher_init */
 694
 695 static void
 696 cmp_matcher_destroy(sdb_object_t *obj)
 697 {
 698         sdb_object_deref(SDB_OBJ(CMP_M(obj)->left));
 699         sdb_object_deref(SDB_OBJ(CMP_M(obj)->right));
 700 } /* cmp_matcher_destroy */
 701
 702 static int
 703 uop_matcher_init(sdb_object_t *obj, va_list ap)
 704 {
 705         M(obj)->type = va_arg(ap, int);
 706         if (M(obj)->type != MATCHER_NOT)
 707                 return -1;
 708
 709         UOP_M(obj)->op = va_arg(ap, sdb_store_matcher_t *);
 710         sdb_object_ref(SDB_OBJ(UOP_M(obj)->op));
 711
 712         if (! UOP_M(obj)->op)
 713                 return -1;
 714         return 0;
 715 } /* uop_matcher_init */
 716
 717 static void
 718 uop_matcher_destroy(sdb_object_t *obj)
 719 {
 720         if (UOP_M(obj)->op)
 721                 sdb_object_deref(SDB_OBJ(UOP_M(obj)->op));
 722 } /* uop_matcher_destroy */
 723
 724 static int
 725 isnull_matcher_init(sdb_object_t *obj, va_list ap)
 726 {
 727         M(obj)->type = va_arg(ap, int);
 728         if ((M(obj)->type != MATCHER_ISNULL) && (M(obj)->type != MATCHER_ISNNULL))
 729                 return -1;
 730
 731         ISNULL_M(obj)->expr = va_arg(ap, sdb_store_expr_t *);
 732         sdb_object_ref(SDB_OBJ(ISNULL_M(obj)->expr));
 733         return 0;
 734 } /* isnull_matcher_init */
 735
 736 static void
 737 isnull_matcher_destroy(sdb_object_t *obj)
 738 {
 739         sdb_object_deref(SDB_OBJ(ISNULL_M(obj)->expr));
 740         ISNULL_M(obj)->expr = NULL;
 741 } /* isnull_matcher_destroy */
 742
 743 static sdb_type_t name_type = {
 744         /* size = */ sizeof(name_matcher_t),
 745         /* init = */ name_matcher_init,
 746         /* destroy = */ name_matcher_destroy,
 747 };
 748
 749 static sdb_type_t attr_type = {
 750         /* size = */ sizeof(attr_matcher_t),
 751         /* init = */ attr_matcher_init,
 752         /* destroy = */ attr_matcher_destroy,
 753 };
 754
 755 static sdb_type_t cond_type = {
 756         /* size = */ sizeof(cond_matcher_t),
 757         /* init = */ cond_matcher_init,
 758         /* destroy = */ cond_matcher_destroy,
 759 };
 760
 761 static sdb_type_t op_type = {
 762         /* size = */ sizeof(op_matcher_t),
 763         /* init = */ op_matcher_init,
 764         /* destroy = */ op_matcher_destroy,
 765 };
 766
 767 static sdb_type_t uop_type = {
 768         /* size = */ sizeof(uop_matcher_t),
 769         /* init = */ uop_matcher_init,
 770         /* destroy = */ uop_matcher_destroy,
 771 };
 772
 773 static sdb_type_t child_type = {
 774         /* size = */ sizeof(child_matcher_t),
 775         /* init = */ child_matcher_init,
 776         /* destroy = */ child_matcher_destroy,
 777 };
 778
 779 static sdb_type_t cmp_type = {
 780         /* size = */ sizeof(cmp_matcher_t),
 781         /* init = */ cmp_matcher_init,
 782         /* destroy = */ cmp_matcher_destroy,
 783 };
 784
 785 static sdb_type_t isnull_type = {
 786         /* size = */ sizeof(isnull_matcher_t),
 787         /* init = */ isnull_matcher_init,
 788         /* destroy = */ isnull_matcher_destroy,
 789 };
 790
 791 /*
 792  * public API
 793  */
 794
 795 sdb_store_matcher_t *
 796 sdb_store_name_matcher(int type, const char *name, _Bool re)
 797 {
 798         sdb_store_matcher_t *m;
 799
 800         if (re)
 801                 m = M(sdb_object_create("name-matcher", name_type, NULL, name));
 802         else
 803                 m = M(sdb_object_create("name-matcher", name_type, name, NULL));
 804
 805         if (! m)
 806                 return NULL;
 807
 808         NAME_M(m)->obj_type = type;
 809         return m;
 810 } /* sdb_store_name_matcher */
 811
 812 sdb_store_matcher_t *
 813 sdb_store_attr_matcher(const char *name, const char *value, _Bool re)
 814 {
 815         sdb_store_matcher_t *m;
 816
 817         if (! name)
 818                 return NULL;
 819
 820         if (re)
 821                 m = M(sdb_object_create("attr-matcher", attr_type,
 822                                         name, NULL, value));
 823         else
 824                 m = M(sdb_object_create("attr-matcher", attr_type,
 825                                         name, value, NULL));
 826         return m;
 827 } /* sdb_store_attr_matcher */
 828
 829 sdb_store_matcher_t *
 830 sdb_store_child_matcher(int type, sdb_store_matcher_t *m)
 831 {
 832         if (type == SDB_SERVICE)
 833                 type = MATCHER_SERVICE;
 834         else if (type == SDB_METRIC)
 835                 type = MATCHER_METRIC;
 836         else if (type == SDB_ATTRIBUTE)
 837                 type = MATCHER_ATTRIBUTE;
 838         else
 839                 return NULL;
 840         return M(sdb_object_create("any-matcher", child_type, type, m));
 841 } /* sdb_store_child_matcher */
 842
 843 sdb_store_matcher_t *
 844 sdb_store_lt_matcher(sdb_store_cond_t *cond)
 845 {
 846         return M(sdb_object_create("lt-matcher", cond_type,
 847                                 MATCHER_LT, cond));
 848 } /* sdb_store_lt_matcher */
 849
 850 sdb_store_matcher_t *
 851 sdb_store_le_matcher(sdb_store_cond_t *cond)
 852 {
 853         return M(sdb_object_create("le-matcher", cond_type,
 854                                 MATCHER_LE, cond));
 855 } /* sdb_store_le_matcher */
 856
 857 sdb_store_matcher_t *
 858 sdb_store_eq_matcher(sdb_store_cond_t *cond)
 859 {
 860         return M(sdb_object_create("eq-matcher", cond_type,
 861                                 MATCHER_EQ, cond));
 862 } /* sdb_store_eq_matcher */
 863
 864 sdb_store_matcher_t *
 865 sdb_store_ge_matcher(sdb_store_cond_t *cond)
 866 {
 867         return M(sdb_object_create("ge-matcher", cond_type,
 868                                 MATCHER_GE, cond));
 869 } /* sdb_store_ge_matcher */
 870
 871 sdb_store_matcher_t *
 872 sdb_store_gt_matcher(sdb_store_cond_t *cond)
 873 {
 874         return M(sdb_object_create("gt-matcher", cond_type,
 875                                 MATCHER_GT, cond));
 876 } /* sdb_store_gt_matcher */
 877
 878 /*
 879  * TODO: Rename sdb_store_cmp_* to sdb_store_* once the old code is unused and
 880  * has been removed.
 881  */
 882
 883 sdb_store_matcher_t *
 884 sdb_store_cmp_lt(sdb_store_expr_t *left, sdb_store_expr_t *right)
 885 {
 886         return M(sdb_object_create("lt-matcher", cmp_type,
 887                                 MATCHER_CMP_LT, left, right));
 888 } /* sdb_store_cmp_lt */
 889
 890 sdb_store_matcher_t *
 891 sdb_store_cmp_le(sdb_store_expr_t *left, sdb_store_expr_t *right)
 892 {
 893         return M(sdb_object_create("le-matcher", cmp_type,
 894                                 MATCHER_CMP_LE, left, right));
 895 } /* sdb_store_cmp_le */
 896
 897 sdb_store_matcher_t *
 898 sdb_store_cmp_eq(sdb_store_expr_t *left, sdb_store_expr_t *right)
 899 {
 900         return M(sdb_object_create("eq-matcher", cmp_type,
 901                                 MATCHER_CMP_EQ, left, right));
 902 } /* sdb_store_cmp_eq */
 903
 904 sdb_store_matcher_t *
 905 sdb_store_cmp_ne(sdb_store_expr_t *left, sdb_store_expr_t *right)
 906 {
 907         return M(sdb_object_create("ne-matcher", cmp_type,
 908                                 MATCHER_CMP_NE, left, right));
 909 } /* sdb_store_cmp_ne */
 910
 911 sdb_store_matcher_t *
 912 sdb_store_cmp_ge(sdb_store_expr_t *left, sdb_store_expr_t *right)
 913 {
 914         return M(sdb_object_create("ge-matcher", cmp_type,
 915                                 MATCHER_CMP_GE, left, right));
 916 } /* sdb_store_cmp_ge */
 917
 918 sdb_store_matcher_t *
 919 sdb_store_cmp_gt(sdb_store_expr_t *left, sdb_store_expr_t *right)
 920 {
 921         return M(sdb_object_create("gt-matcher", cmp_type,
 922                                 MATCHER_CMP_GT, left, right));
 923 } /* sdb_store_cmp_gt */
 924
 925 sdb_store_matcher_t *
 926 sdb_store_in_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right)
 927 {
 928         return M(sdb_object_create("in-matcher", cmp_type,
 929                                 MATCHER_IN, left, right));
 930 } /* sdb_store_in_matcher */
 931
 932 sdb_store_matcher_t *
 933 sdb_store_regex_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right)
 934 {
 935         if (! right->type) {
 936                 if ((right->data.type != SDB_TYPE_STRING)
 937                                 && (right->data.type != SDB_TYPE_REGEX))
 938                         return NULL;
 939
 940                 if (right->data.type == SDB_TYPE_STRING) {
 941                         char *raw = right->data.data.string;
 942                         if (sdb_data_parse(raw, SDB_TYPE_REGEX, &right->data))
 943                                 return NULL;
 944                         free(raw);
 945                 }
 946         }
 947         return M(sdb_object_create("regex-matcher", cmp_type,
 948                                 MATCHER_REGEX, left, right));
 949 } /* sdb_store_regex_matcher */
 950
 951 sdb_store_matcher_t *
 952 sdb_store_nregex_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right)
 953 {
 954         sdb_store_matcher_t *m = sdb_store_regex_matcher(left, right);
 955         if (! m)
 956                 return NULL;
 957         m->type = MATCHER_NREGEX;
 958         return m;
 959 } /* sdb_store_nregex_matcher */
 960
 961 sdb_store_matcher_t *
 962 sdb_store_isnull_matcher(sdb_store_expr_t *expr)
 963 {
 964         return M(sdb_object_create("isnull-matcher", isnull_type,
 965                                 MATCHER_ISNULL, expr));
 966 } /* sdb_store_isnull_matcher */
 967
 968 sdb_store_matcher_t *
 969 sdb_store_isnnull_matcher(sdb_store_expr_t *expr)
 970 {
 971         return M(sdb_object_create("isnull-matcher", isnull_type,
 972                                 MATCHER_ISNNULL, expr));
 973 } /* sdb_store_isnnull_matcher */
 974
 975 sdb_store_matcher_op_cb
 976 sdb_store_parse_matcher_op(const char *op)
 977 {
 978         if (! strcasecmp(op, "<"))
 979                 return sdb_store_cmp_lt;
 980         else if (! strcasecmp(op, "<="))
 981                 return sdb_store_cmp_le;
 982         else if (! strcasecmp(op, "="))
 983                 return sdb_store_cmp_eq;
 984         else if (! strcasecmp(op, "!="))
 985                 return sdb_store_cmp_ne;
 986         else if (! strcasecmp(op, ">="))
 987                 return sdb_store_cmp_ge;
 988         else if (! strcasecmp(op, ">"))
 989                 return sdb_store_cmp_gt;
 990         else if (! strcasecmp(op, "=~"))
 991                 return sdb_store_regex_matcher;
 992         else if (! strcasecmp(op, "!~"))
 993                 return sdb_store_nregex_matcher;
 994         return NULL;
 995 } /* sdb_store_parse_matcher_op */
 996
 997 int
 998 sdb_store_parse_object_type_plural(const char *name)
 999 {
1000         if (! strcasecmp(name, "hosts"))
1001                 return SDB_HOST;
1002         else if (! strcasecmp(name, "services"))
1003                 return SDB_SERVICE;
1004         else if (! strcasecmp(name, "metrics"))
1005                 return SDB_METRIC;
1006         return -1;
1007 } /* sdb_store_parse_object_type_plural */
1008
1009 int
1010 sdb_store_parse_field_name(const char *name)
1011 {
1012         if (! strcasecmp(name, "name"))
1013                 return SDB_FIELD_NAME;
1014         else if (! strcasecmp(name, "last_update"))
1015                 return SDB_FIELD_LAST_UPDATE;
1016         else if (! strcasecmp(name, "age"))
1017                 return SDB_FIELD_AGE;
1018         else if (! strcasecmp(name, "interval"))
1019                 return SDB_FIELD_INTERVAL;
1020         else if (! strcasecmp(name, "backend"))
1021                 return SDB_FIELD_BACKEND;
1022         return -1;
1023 } /* sdb_store_parse_field_name */
1024
1025 static sdb_store_matcher_t *
1026 maybe_inv_matcher(sdb_store_matcher_t *m, _Bool inv)
1027 {
1028         sdb_store_matcher_t *tmp;
1029
1030         if ((! m) || (! inv))
1031                 return m;
1032
1033         tmp = sdb_store_inv_matcher(m);
1034         /* pass ownership to the inverse matcher */
1035         sdb_object_deref(SDB_OBJ(m));
1036         return tmp;
1037 } /* maybe_inv_matcher */
1038
1039 sdb_store_matcher_t *
1040 sdb_store_matcher_parse_cmp(const char *obj_type,
1041                 const char *op, sdb_store_expr_t *expr)
1042 {
1043         int type = -1;
1044         _Bool inv = 0;
1045         _Bool re = 0;
1046
1047         sdb_data_t value = SDB_DATA_INIT;
1048         sdb_store_matcher_t *m = NULL;
1049
1050         if (! strcasecmp(obj_type, "host"))
1051                 type = SDB_HOST;
1052         else if (! strcasecmp(obj_type, "service"))
1053                 type = SDB_SERVICE;
1054         else if (! strcasecmp(obj_type, "metric"))
1055                 type = SDB_METRIC;
1056         else if (! strcasecmp(obj_type, "attribute"))
1057                 type = SDB_ATTRIBUTE;
1058         else
1059                 return NULL;
1060
1061         /* XXX: this code sucks! */
1062         if (! strcasecmp(op, "=")) {
1063                 /* nothing to do */
1064         }
1065         else if (! strcasecmp(op, "!=")) {
1066                 inv = 1;
1067         }
1068         else if (! strcasecmp(op, "=~")) {
1069                 re = 1;
1070         }
1071         else if (! strcasecmp(op, "!~")) {
1072                 inv = 1;
1073                 re = 1;
1074         }
1075         else
1076                 return NULL;
1077
1078         if (! expr)
1079                 return NULL;
1080
1081         if (sdb_store_expr_eval(expr, /* obj */ NULL, &value, /* filter */ NULL)
1082                         || (value.type != SDB_TYPE_STRING)) {
1083                 sdb_data_free_datum(&value);
1084                 return NULL;
1085         }
1086
1087         m = sdb_store_name_matcher(type, value.data.string, re);
1088         sdb_data_free_datum(&value);
1089         return maybe_inv_matcher(m, inv);
1090 } /* sdb_store_matcher_parse_cmp */
1091
1092 sdb_store_matcher_t *
1093 sdb_store_dis_matcher(sdb_store_matcher_t *left, sdb_store_matcher_t *right)
1094 {
1095         return M(sdb_object_create("dis-matcher", op_type, MATCHER_OR,
1096                                 left, right));
1097 } /* sdb_store_dis_matcher */
1098
1099 sdb_store_matcher_t *
1100 sdb_store_con_matcher(sdb_store_matcher_t *left, sdb_store_matcher_t *right)
1101 {
1102         return M(sdb_object_create("con-matcher", op_type, MATCHER_AND,
1103                                 left, right));
1104 } /* sdb_store_con_matcher */
1105
1106 sdb_store_matcher_t *
1107 sdb_store_inv_matcher(sdb_store_matcher_t *m)
1108 {
1109         return M(sdb_object_create("inv-matcher", uop_type, MATCHER_NOT, m));
1110 } /* sdb_store_inv_matcher */
1111
1112 int
1113 sdb_store_matcher_matches(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
1114                 sdb_store_matcher_t *filter)
1115 {
1116         if (filter && (! sdb_store_matcher_matches(filter, obj, NULL)))
1117                 return 0;
1118
1119         /* "NULL" always matches */
1120         if ((! m) || (! obj))
1121                 return 1;
1122
1123         if ((m->type < 0) || ((size_t)m->type >= SDB_STATIC_ARRAY_LEN(matchers)))
1124                 return 0;
1125
1126         return matchers[m->type](m, obj, filter);
1127 } /* sdb_store_matcher_matches */
1128
1129 int
1130 sdb_store_scan(sdb_store_matcher_t *m, sdb_store_matcher_t *filter,
1131                 sdb_store_lookup_cb cb, void *user_data)
1132 {
1133         scan_iter_data_t data = { m, filter, cb, user_data };
1134
1135         if (! cb)
1136                 return -1;
1137         return sdb_store_iterate(scan_iter, &data);
1138 } /* sdb_store_scan */
1139
1140 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
1141