X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fcore%2Fstore_lookup.c;h=f57cb05cab292fa53d86b56c936d35403fc77351;hb=4436642effe44c7d891bdcc4b207aeddb1c0e43d;hp=52739a6a836155fd3ba465a688cb5db222f4aa91;hpb=e5d944cf9ebf73282feccd6bda92e25f0d7523a2;p=sysdb.git diff --git a/src/core/store_lookup.c b/src/core/store_lookup.c index 52739a6..f57cb05 100644 --- a/src/core/store_lookup.c +++ b/src/core/store_lookup.c @@ -47,6 +47,8 @@ #include #include +#include + /* * private data types */ @@ -71,6 +73,44 @@ lookup_iter(sdb_store_base_t *obj, void *user_data) return 0; } /* lookup_iter */ +static sdb_store_base_t * +attr_get(sdb_store_base_t *host, const char *name) +{ + sdb_llist_iter_t *iter = NULL; + sdb_store_base_t *attr = NULL; + + assert(host->type == SDB_HOST); + + iter = sdb_llist_get_iter(SDB_STORE_OBJ(host)->attributes); + while (sdb_llist_iter_has_next(iter)) { + sdb_attribute_t *a = SDB_ATTR(sdb_llist_iter_get_next(iter)); + + if (strcasecmp(name, SDB_OBJ(a)->name)) + continue; + attr = STORE_BASE(a); + break; + } + sdb_llist_iter_destroy(iter); + return attr; +} /* attr_get */ + +/* + * conditional implementations + */ + +static int +attr_cmp(sdb_store_base_t *obj, sdb_store_cond_t *cond) +{ + sdb_attribute_t *attr; + + attr = SDB_ATTR(attr_get(obj, ATTR_C(cond)->name)); + if (! attr) + return INT_MAX; + if (attr->value.type != ATTR_C(cond)->value.type) + return INT_MAX; + return sdb_data_cmp(&attr->value, &ATTR_C(cond)->value); +} /* attr_cmp */ + /* * matcher implementations */ @@ -78,8 +118,6 @@ lookup_iter(sdb_store_base_t *obj, void *user_data) static int match_string(string_matcher_t *m, const char *name) { - assert(m); - if ((! m->name) && (! m->name_re)) return 1; @@ -99,7 +137,7 @@ match_logical(sdb_store_matcher_t *m, sdb_store_base_t *obj) { int status; - assert(m && obj); + assert((m->type == MATCHER_AND) || (m->type == MATCHER_OR)); assert(OP_M(m)->left && OP_M(m)->right); status = sdb_store_matcher_matches(OP_M(m)->left, obj); @@ -115,10 +153,8 @@ match_logical(sdb_store_matcher_t *m, sdb_store_base_t *obj) static int match_unary(sdb_store_matcher_t *m, sdb_store_base_t *obj) { - assert(m && obj); - assert(UOP_M(m)->op); - assert(m->type == MATCHER_NOT); + assert(UOP_M(m)->op); return !sdb_store_matcher_matches(UOP_M(m)->op, obj); } /* match_unary */ @@ -129,18 +165,14 @@ match_name(sdb_store_matcher_t *m, sdb_store_base_t *obj) sdb_llist_iter_t *iter = NULL; int status = 0; - assert(m && obj); assert(m->type == MATCHER_NAME); - if (obj->type != SDB_HOST) - return 0; - switch (NAME_M(m)->obj_type) { case SDB_HOST: return match_string(&NAME_M(m)->name, obj->super.name); break; case SDB_SERVICE: - iter = sdb_llist_get_iter(SDB_STORE_OBJ(obj)->children); + iter = sdb_llist_get_iter(SDB_STORE_OBJ(obj)->services); break; case SDB_ATTRIBUTE: iter = sdb_llist_get_iter(SDB_STORE_OBJ(obj)->attributes); @@ -161,34 +193,67 @@ match_name(sdb_store_matcher_t *m, sdb_store_base_t *obj) static int match_attr(sdb_store_matcher_t *m, sdb_store_base_t *obj) { - sdb_llist_iter_t *iter = NULL; - int status = 0; + sdb_attribute_t *attr; - assert(m && obj); assert(m->type == MATCHER_ATTR); + assert(ATTR_M(m)->name); - if (obj->type != SDB_HOST) - return 0; - - iter = sdb_llist_get_iter(SDB_STORE_OBJ(obj)->attributes); - while (sdb_llist_iter_has_next(iter)) { - sdb_attribute_t *attr = SDB_ATTR(sdb_llist_iter_get_next(iter)); + attr = SDB_ATTR(attr_get(obj, ATTR_M(m)->name)); + if (attr) { char buf[sdb_data_strlen(&attr->value) + 1]; - - if (ATTR_M(m)->name && strcasecmp(ATTR_M(m)->name, SDB_OBJ(attr)->name)) - continue; - if (sdb_data_format(&attr->value, buf, sizeof(buf), SDB_UNQUOTED) <= 0) return 0; - if (match_string(&ATTR_M(m)->value, buf)) { - status = 1; - break; - } + if (match_string(&ATTR_M(m)->value, buf)) + return 1; } - sdb_llist_iter_destroy(iter); - return status; + return 0; } /* match_attr */ +static int +match_lt(sdb_store_matcher_t *m, sdb_store_base_t *obj) +{ + int status; + assert(m->type == MATCHER_LT); + status = COND_M(m)->cond->cmp(obj, COND_M(m)->cond); + return (status != INT_MAX) && (status < 0); +} /* match_lt */ + +static int +match_le(sdb_store_matcher_t *m, sdb_store_base_t *obj) +{ + int status; + assert(m->type == MATCHER_LE); + status = COND_M(m)->cond->cmp(obj, COND_M(m)->cond); + return (status != INT_MAX) && (status <= 0); +} /* match_le */ + +static int +match_eq(sdb_store_matcher_t *m, sdb_store_base_t *obj) +{ + int status; + assert(m->type == MATCHER_EQ); + status = COND_M(m)->cond->cmp(obj, COND_M(m)->cond); + return (status != INT_MAX) && (! status); +} /* match_eq */ + +static int +match_ge(sdb_store_matcher_t *m, sdb_store_base_t *obj) +{ + int status; + assert(m->type == MATCHER_GE); + status = COND_M(m)->cond->cmp(obj, COND_M(m)->cond); + return (status != INT_MAX) && (status >= 0); +} /* match_ge */ + +static int +match_gt(sdb_store_matcher_t *m, sdb_store_base_t *obj) +{ + int status; + assert(m->type == MATCHER_GT); + status = COND_M(m)->cond->cmp(obj, COND_M(m)->cond); + return (status != INT_MAX) && (status > 0); +} /* match_gt */ + typedef int (*matcher_cb)(sdb_store_matcher_t *, sdb_store_base_t *); /* this array needs to be indexable by the matcher types; @@ -199,6 +264,48 @@ static matcher_cb matchers[] = { match_unary, match_name, match_attr, + match_lt, + match_le, + match_eq, + match_ge, + match_gt, +}; + +/* + * private conditional types + */ + +static int +attr_cond_init(sdb_object_t *obj, va_list ap) +{ + const char *name = va_arg(ap, const char *); + const sdb_data_t *value = va_arg(ap, const sdb_data_t *); + + if (! name) + return -1; + + SDB_STORE_COND(obj)->cmp = attr_cmp; + + ATTR_C(obj)->name = strdup(name); + if (! ATTR_C(obj)->name) + return -1; + if (sdb_data_copy(&ATTR_C(obj)->value, value)) + return -1; + return 0; +} /* attr_cond_init */ + +static void +attr_cond_destroy(sdb_object_t *obj) +{ + if (ATTR_C(obj)->name) + free(ATTR_C(obj)->name); + sdb_data_free_datum(&ATTR_C(obj)->value); +} /* attr_cond_destroy */ + +static sdb_type_t attr_cond_type = { + /* size = */ sizeof(attr_cond_t), + /* init = */ attr_cond_init, + /* destroy = */ attr_cond_destroy, }; /* @@ -315,6 +422,42 @@ attr_tostring(sdb_store_matcher_t *m, char *buf, size_t buflen) return buf; } /* attr_tostring */ +static int +cond_matcher_init(sdb_object_t *obj, va_list ap) +{ + int type = va_arg(ap, int); + sdb_store_cond_t *cond = va_arg(ap, sdb_store_cond_t *); + + if (! cond) + return -1; + + sdb_object_ref(SDB_OBJ(cond)); + + M(obj)->type = type; + COND_M(obj)->cond = cond; + return 0; +} /* cond_matcher_init */ + +static void +cond_matcher_destroy(sdb_object_t *obj) +{ + sdb_object_deref(SDB_OBJ(COND_M(obj)->cond)); +} /* cond_matcher_destroy */ + +static char * +cond_tostring(sdb_store_matcher_t *m, char *buf, size_t buflen) +{ + if (COND_M(m)->cond->cmp == attr_cmp) { + char value[buflen]; + if (sdb_data_format(&ATTR_C(COND_M(m)->cond)->value, + value, sizeof(value), SDB_SINGLE_QUOTED) < 0) + snprintf(value, sizeof(value), "ERR"); + snprintf(buf, buflen, "ATTR[%s]{ %s %s }", + ATTR_C(COND_M(m)->cond)->name, MATCHER_SYM(m->type), value); + } + return buf; +} /* cond_tostring */ + static int op_matcher_init(sdb_object_t *obj, va_list ap) { @@ -411,6 +554,12 @@ static sdb_type_t attr_type = { /* destroy = */ attr_matcher_destroy, }; +static sdb_type_t cond_type = { + /* size = */ sizeof(cond_matcher_t), + /* init = */ cond_matcher_init, + /* destroy = */ cond_matcher_destroy, +}; + static sdb_type_t op_type = { /* size = */ sizeof(op_matcher_t), /* init = */ op_matcher_init, @@ -433,12 +582,24 @@ static matcher_tostring_cb matchers_tostring[] = { uop_tostring, name_tostring, attr_tostring, + cond_tostring, + cond_tostring, + cond_tostring, + cond_tostring, + cond_tostring, }; /* * public API */ +sdb_store_cond_t * +sdb_store_attr_cond(const char *name, const sdb_data_t *value) +{ + return SDB_STORE_COND(sdb_object_create("attr-cond", attr_cond_type, + name, value)); +} /* sdb_store_attr_cond */ + sdb_store_matcher_t * sdb_store_name_matcher(int type, const char *name, _Bool re) { @@ -461,6 +622,9 @@ sdb_store_name_matcher(int type, const char *name, _Bool re) sdb_store_matcher_t * sdb_store_attr_matcher(const char *name, const char *value, _Bool re) { + if (! name) + return NULL; + if (re) return M(sdb_object_create("attr-matcher", attr_type, name, NULL, value)); @@ -468,9 +632,94 @@ sdb_store_attr_matcher(const char *name, const char *value, _Bool re) name, value, NULL)); } /* sdb_store_attr_matcher */ +sdb_store_matcher_t * +sdb_store_lt_matcher(sdb_store_cond_t *cond) +{ + return M(sdb_object_create("lt-matcher", cond_type, + MATCHER_LT, cond)); +} /* sdb_store_lt_matcher */ + +sdb_store_matcher_t * +sdb_store_le_matcher(sdb_store_cond_t *cond) +{ + return M(sdb_object_create("le-matcher", cond_type, + MATCHER_LE, cond)); +} /* sdb_store_le_matcher */ + +sdb_store_matcher_t * +sdb_store_eq_matcher(sdb_store_cond_t *cond) +{ + return M(sdb_object_create("eq-matcher", cond_type, + MATCHER_EQ, cond)); +} /* sdb_store_eq_matcher */ + +sdb_store_matcher_t * +sdb_store_ge_matcher(sdb_store_cond_t *cond) +{ + return M(sdb_object_create("ge-matcher", cond_type, + MATCHER_GE, cond)); +} /* sdb_store_ge_matcher */ + +sdb_store_matcher_t * +sdb_store_gt_matcher(sdb_store_cond_t *cond) +{ + return M(sdb_object_create("gt-matcher", cond_type, + MATCHER_GT, cond)); +} /* sdb_store_gt_matcher */ + +static sdb_store_matcher_t * +parse_attr_cmp(const char *attr, const char *op, const sdb_data_t *value) +{ + sdb_store_matcher_t *(*matcher)(sdb_store_cond_t *) = NULL; + sdb_store_matcher_t *m; + sdb_store_cond_t *cond; + _Bool inv = 0; + + /* TODO: this will reject any attributes called "name"; + * use a different syntax for querying objects by name */ + if (! strcasecmp(attr, "name")) + return NULL; + + if (! strcasecmp(op, "<")) + matcher = sdb_store_lt_matcher; + else if (! strcasecmp(op, "<=")) + matcher = sdb_store_le_matcher; + else if (! strcasecmp(op, "=")) + matcher = sdb_store_eq_matcher; + else if (! strcasecmp(op, ">=")) + matcher = sdb_store_ge_matcher; + else if (! strcasecmp(op, ">")) + matcher = sdb_store_gt_matcher; + else if (! strcasecmp(op, "!=")) { + matcher = sdb_store_eq_matcher; + inv = 1; + } + else + return NULL; + + cond = sdb_store_attr_cond(attr, value); + if (! cond) + return NULL; + + m = matcher(cond); + /* pass ownership to 'm' or destroy in case of an error */ + sdb_object_deref(SDB_OBJ(cond)); + if (! m) + return NULL; + + if (inv) { + sdb_store_matcher_t *tmp; + tmp = sdb_store_inv_matcher(m); + /* pass ownership to the inverse matcher */ + sdb_object_deref(SDB_OBJ(m)); + m = tmp; + } + return m; +} /* parse_attr_cmp */ + sdb_store_matcher_t * sdb_store_matcher_parse_cmp(const char *obj_type, const char *attr, - const char *op, const char *value) + const char *op, const sdb_data_t *value) { int type = -1; _Bool inv = 0; @@ -484,8 +733,10 @@ sdb_store_matcher_parse_cmp(const char *obj_type, const char *attr, type = SDB_SERVICE; else if (! strcasecmp(obj_type, "attribute")) type = SDB_ATTRIBUTE; + else + return NULL; - /* TODO: support other operators */ + /* XXX: this code sucks! */ if (! strcasecmp(op, "=")) { /* nothing to do */ } @@ -499,13 +750,21 @@ sdb_store_matcher_parse_cmp(const char *obj_type, const char *attr, inv = 1; re = 1; } + else if (type == SDB_ATTRIBUTE) + return parse_attr_cmp(attr, op, value); else return NULL; + if (value->type != SDB_TYPE_STRING) { + if (type == SDB_ATTRIBUTE) + return parse_attr_cmp(attr, op, value); + return NULL; + } + if (! strcasecmp(attr, "name")) - m = sdb_store_name_matcher(type, value, re); + m = sdb_store_name_matcher(type, value->data.string, re); else if (type == SDB_ATTRIBUTE) - m = sdb_store_attr_matcher(attr, value, re); + m = sdb_store_attr_matcher(attr, value->data.string, re); if (! m) return NULL; @@ -543,6 +802,9 @@ sdb_store_inv_matcher(sdb_store_matcher_t *m) int sdb_store_matcher_matches(sdb_store_matcher_t *m, sdb_store_base_t *obj) { + if (obj->type != SDB_HOST) + return 0; + /* "NULL" always matches */ if ((! m) || (! obj)) return 1;