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