src/frontend/analyzer.c

   1 /*
   2  * SysDB - src/frontend/analyzer.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 #include "sysdb.h"
  29
  30 #include "core/store-private.h"
  31 #include "frontend/connection-private.h"
  32 #include "frontend/parser.h"
  33 #include "utils/error.h"
  34 #include "utils/strbuf.h"
  35
  36 #include <assert.h>
  37
  38 /*
  39  * private helper functions
  40  */
  41
  42 static void
  43 iter_error(sdb_strbuf_t *errbuf, int op, sdb_store_expr_t *iter, int context)
  44 {
  45         sdb_strbuf_sprintf(errbuf, "Invalid %s iterator: %s %s "
  46                         "not iterable in %s context", MATCHER_SYM(op),
  47                         EXPR_TO_STRING(iter), SDB_STORE_TYPE_TO_NAME(iter->data_type),
  48                         context == -1 ? "generic" : SDB_STORE_TYPE_TO_NAME(context));
  49 } /* iter_error */
  50
  51 static void
  52 iter_op_error(sdb_strbuf_t *errbuf, int op,
  53                 int iter_type, int cmp, int value_type)
  54 {
  55         sdb_strbuf_sprintf(errbuf, "Invalid iterator %s %s %s %s",
  56                         MATCHER_SYM(op), SDB_TYPE_TO_STRING(iter_type),
  57                         MATCHER_SYM(cmp), SDB_TYPE_TO_STRING(value_type));
  58         if ((iter_type & 0xff) != value_type)
  59                 sdb_strbuf_append(errbuf, " (type mismatch)");
  60         else
  61                 sdb_strbuf_append(errbuf, " (invalid operator)");
  62 } /* iter_op_error */
  63
  64 static void
  65 cmp_error(sdb_strbuf_t *errbuf, int op, int left, int right)
  66 {
  67         sdb_strbuf_sprintf(errbuf, "Invalid operator %s for types %s and %s",
  68                         MATCHER_SYM(op), SDB_TYPE_TO_STRING(left),
  69                         SDB_TYPE_TO_STRING(right));
  70 } /* cmp_error */
  71
  72 static void
  73 op_error(sdb_strbuf_t *errbuf, int op, int left, int right)
  74 {
  75         sdb_strbuf_sprintf(errbuf, "Invalid operator %s for types %s and %s",
  76                         SDB_DATA_OP_TO_STRING(op), SDB_TYPE_TO_STRING(left),
  77                         SDB_TYPE_TO_STRING(right));
  78 } /* cmp_error */
  79
  80 static int
  81 analyze_expr(int context, sdb_store_expr_t *e, sdb_strbuf_t *errbuf)
  82 {
  83         if (! e)
  84                 return 0;
  85
  86         if ((e->type < TYPED_EXPR) || (SDB_DATA_CONCAT < e->type)) {
  87                 sdb_strbuf_sprintf(errbuf, "Invalid expression of type %d", e->type);
  88                 return -1;
  89         }
  90
  91         switch (e->type) {
  92                 case TYPED_EXPR:
  93                         if (analyze_expr((int)e->data.data.integer, e->left, errbuf))
  94                                 return -1;
  95                         if (context == (int)e->data.data.integer)
  96                                 return 0;
  97                         if ((e->data.data.integer == SDB_HOST) &&
  98                                         ((context == SDB_SERVICE) || (context == SDB_METRIC)
  99                                                 || (context < 0)))
 100                                 return 0;
 101                         sdb_strbuf_sprintf(errbuf, "Invalid expression %s.%s "
 102                                         "in %s context",
 103                                         SDB_STORE_TYPE_TO_NAME(e->data.data.integer),
 104                                         EXPR_TO_STRING(e->left),
 105                                         context == -1 ? "generic" : SDB_STORE_TYPE_TO_NAME(context));
 106                         return -1;
 107
 108                 case ATTR_VALUE:
 109                 case 0:
 110                         break;
 111
 112                 case FIELD_VALUE:
 113                         if ((e->data.data.integer == SDB_FIELD_VALUE)
 114                                         && (context != SDB_ATTRIBUTE)) {
 115                                 sdb_strbuf_sprintf(errbuf, "Invalid expression %s.value "
 116                                                 "(only attributes have a value)",
 117                                                 SDB_STORE_TYPE_TO_NAME(context));
 118                                 return -1;
 119                         }
 120                         break;
 121
 122                 default:
 123                         if (analyze_expr(context, e->left, errbuf))
 124                                 return -1;
 125                         if (analyze_expr(context, e->right, errbuf))
 126                                 return -1;
 127
 128                         if ((e->left->data_type > 0) && (e->right->data_type > 0)) {
 129                                 if (sdb_data_expr_type(e->type, e->left->data_type,
 130                                                         e->right->data_type) < 0) {
 131                                         op_error(errbuf, e->type, e->left->data_type,
 132                                                         e->right->data_type);
 133                                         return -1;
 134                                 }
 135                         }
 136                         break;
 137         }
 138         return 0;
 139 } /* analyze_expr */
 140
 141 static int
 142 analyze_matcher(int context, int parent_type,
 143                 sdb_store_matcher_t *m, sdb_strbuf_t *errbuf)
 144 {
 145         if (! m)
 146                 return 0;
 147
 148         switch (m->type) {
 149                 case MATCHER_OR:
 150                 case MATCHER_AND:
 151                         assert(OP_M(m)->left && OP_M(m)->right);
 152                         if (analyze_matcher(context, m->type, OP_M(m)->left, errbuf))
 153                                 return -1;
 154                         if (analyze_matcher(context, m->type, OP_M(m)->right, errbuf))
 155                                 return -1;
 156                         break;
 157
 158                 case MATCHER_NOT:
 159                         assert(UOP_M(m)->op);
 160                         if (analyze_matcher(context, m->type, UOP_M(m)->op, errbuf))
 161                                 return -1;
 162                         break;
 163
 164                 case MATCHER_ANY:
 165                 case MATCHER_ALL:
 166                 {
 167                         int child_context = -1;
 168                         int left_type = -1;
 169                         int type = -1;
 170
 171                         assert(ITER_M(m)->m);
 172
 173                         if ((ITER_M(m)->iter->type == TYPED_EXPR)
 174                                         || (ITER_M(m)->iter->type == FIELD_VALUE))
 175                                 type = (int)ITER_M(m)->iter->data.data.integer;
 176
 177                         if (context == -1) { /* inside a filter */
 178                                 /* attributes are always iterable */
 179                                 if ((ITER_M(m)->iter->type == TYPED_EXPR)
 180                                                 && (type != SDB_ATTRIBUTE)) {
 181                                         iter_error(errbuf, m->type, ITER_M(m)->iter, context);
 182                                         return -1;
 183                                 }
 184                                 /* backends are always iterable */
 185                                 if ((ITER_M(m)->iter->type == FIELD_VALUE)
 186                                                 && (! (type != SDB_FIELD_BACKEND))) {
 187                                         iter_error(errbuf, m->type, ITER_M(m)->iter, context);
 188                                         return -1;
 189                                 }
 190                         }
 191                         else if (! sdb_store_expr_iterable(ITER_M(m)->iter, context)) {
 192                                 iter_error(errbuf, m->type, ITER_M(m)->iter, context);
 193                                 return -1;
 194                         }
 195
 196                         if (ITER_M(m)->iter->type == TYPED_EXPR) {
 197                                 child_context = type;
 198                                 left_type = ITER_M(m)->iter->data_type;
 199                         }
 200                         else if (ITER_M(m)->iter->type == FIELD_VALUE) {
 201                                 child_context = context;
 202                                 /* element type of the field */
 203                                 left_type = ITER_M(m)->iter->data_type & 0xff;
 204                         }
 205                         else if (! ITER_M(m)->iter->type) {
 206                                 child_context = context;
 207                                 /* elements of the array constant */
 208                                 left_type = ITER_M(m)->iter->data.type & 0xff;
 209                         }
 210                         else {
 211                                 iter_error(errbuf, m->type, ITER_M(m)->iter, context);
 212                                 return -1;
 213                         }
 214
 215                         /* any ary operator will do but these are the once
 216                          * we currently support */
 217                         if ((ITER_M(m)->m->type != MATCHER_LT)
 218                                         && (ITER_M(m)->m->type != MATCHER_LE)
 219                                         && (ITER_M(m)->m->type != MATCHER_EQ)
 220                                         && (ITER_M(m)->m->type != MATCHER_NE)
 221                                         && (ITER_M(m)->m->type != MATCHER_GE)
 222                                         && (ITER_M(m)->m->type != MATCHER_GT)
 223                                         && (ITER_M(m)->m->type != MATCHER_REGEX)
 224                                         && (ITER_M(m)->m->type != MATCHER_NREGEX)) {
 225                                 iter_op_error(errbuf, m->type,
 226                                                 left_type, ITER_M(m)->m->type,
 227                                                 CMP_M(ITER_M(m)->m)->right->data_type);
 228                                 return -1;
 229                         }
 230                         if ((left_type >= 0)
 231                                         && (CMP_M(ITER_M(m)->m)->right->data_type >= 0)) {
 232                                 if (left_type != CMP_M(ITER_M(m)->m)->right->data_type) {
 233                                         iter_op_error(errbuf, m->type,
 234                                                         left_type, ITER_M(m)->m->type,
 235                                                         CMP_M(ITER_M(m)->m)->right->data_type);
 236                                         return -1;
 237                                 }
 238                         }
 239                         if (child_context <= 0) {
 240                                 sdb_strbuf_sprintf(errbuf, "Unable to determine the context "
 241                                                 "(object type) of iterator %s %s %s %s",
 242                                                 MATCHER_SYM(m->type), SDB_TYPE_TO_STRING(left_type),
 243                                                 MATCHER_SYM(ITER_M(m)->m->type),
 244                                                 SDB_TYPE_TO_STRING(CMP_M(ITER_M(m)->m)->right->data_type));
 245                         }
 246                         if (analyze_matcher(child_context, m->type, ITER_M(m)->m, errbuf))
 247                                 return -1;
 248                         break;
 249                 }
 250
 251                 case MATCHER_LT:
 252                 case MATCHER_LE:
 253                 case MATCHER_EQ:
 254                 case MATCHER_NE:
 255                 case MATCHER_GE:
 256                 case MATCHER_GT:
 257                 {
 258                         int left_type = -1;
 259
 260                         assert(CMP_M(m)->right);
 261                         if ((parent_type == MATCHER_ALL)
 262                                         || (parent_type == MATCHER_ANY)) {
 263                                 assert(! CMP_M(m)->left);
 264                         }
 265                         else {
 266                                 assert(CMP_M(m)->left);
 267                                 left_type = CMP_M(m)->left->data_type;
 268                         }
 269
 270                         if (analyze_expr(context, CMP_M(m)->left, errbuf))
 271                                 return -1;
 272                         if (analyze_expr(context, CMP_M(m)->right, errbuf))
 273                                 return -1;
 274
 275                         if ((left_type > 0) && (CMP_M(m)->right->data_type > 0)) {
 276                                 if (left_type == CMP_M(m)->right->data_type)
 277                                         return 0;
 278                                 cmp_error(errbuf, m->type, left_type,
 279                                                 CMP_M(m)->right->data_type);
 280                                 return -1;
 281                         }
 282                         if ((left_type > 0) && (left_type & SDB_TYPE_ARRAY)) {
 283                                 cmp_error(errbuf, m->type, left_type,
 284                                                 CMP_M(m)->right->data_type);
 285                                 return -1;
 286                         }
 287                         if ((CMP_M(m)->right->data_type > 0)
 288                                         && (CMP_M(m)->right->data_type & SDB_TYPE_ARRAY)) {
 289                                 cmp_error(errbuf, m->type, left_type,
 290                                                 CMP_M(m)->right->data_type);
 291                                 return -1;
 292                         }
 293                         break;
 294                 }
 295
 296                 case MATCHER_IN:
 297                 case MATCHER_NIN:
 298                         if (analyze_expr(context, CMP_M(m)->left, errbuf))
 299                                 return -1;
 300                         if (analyze_expr(context, CMP_M(m)->right, errbuf))
 301                                 return -1;
 302
 303                         /* the left operand may be a scalar or an array but the element
 304                          * type has to match */
 305                         if ((CMP_M(m)->right->data_type > 0)
 306                                         && (! (CMP_M(m)->right->data_type & SDB_TYPE_ARRAY))) {
 307                                 cmp_error(errbuf, m->type, CMP_M(m)->left->data_type,
 308                                                 CMP_M(m)->right->data_type);
 309                                 return -1;
 310                         }
 311                         if ((CMP_M(m)->left->data_type > 0)
 312                                         && (CMP_M(m)->right->data_type > 0)) {
 313                                 if ((CMP_M(m)->left->data_type & 0xff)
 314                                                 != (CMP_M(m)->right->data_type & 0xff)) {
 315                                         cmp_error(errbuf, m->type, CMP_M(m)->left->data_type,
 316                                                         CMP_M(m)->right->data_type);
 317                                         return -1;
 318                                 }
 319                         }
 320                         break;
 321
 322                 case MATCHER_REGEX:
 323                 case MATCHER_NREGEX:
 324                         if (analyze_expr(context, CMP_M(m)->left, errbuf))
 325                                 return -1;
 326                         if (analyze_expr(context, CMP_M(m)->right, errbuf))
 327                                 return -1;
 328
 329                         /* all types are supported for the left operand */
 330                         if ((CMP_M(m)->right->data_type > 0)
 331                                         && (CMP_M(m)->right->data_type != SDB_TYPE_REGEX)
 332                                         && (CMP_M(m)->right->data_type != SDB_TYPE_STRING)) {
 333                                 cmp_error(errbuf, m->type, CMP_M(m)->left->data_type,
 334                                                 CMP_M(m)->right->data_type);
 335                                 return -1;
 336                         }
 337                         break;
 338
 339                 case MATCHER_ISNULL:
 340                 case MATCHER_ISNNULL:
 341                         if (analyze_expr(context, ISNULL_M(m)->expr, errbuf))
 342                                 return -1;
 343                         break;
 344
 345                 default:
 346                         sdb_strbuf_sprintf(errbuf, "Unknown matcher type %d", m->type);
 347                         return -1;
 348         }
 349         return 0;
 350 } /* analyze_matcher */
 351
 352 /*
 353  * public API
 354  */
 355
 356 int
 357 sdb_fe_analyze(sdb_conn_node_t *node, sdb_strbuf_t *errbuf)
 358 {
 359         sdb_store_matcher_t *m = NULL, *filter = NULL;
 360         int context = -1;
 361         int status = 0;
 362
 363         if (! node)
 364                 return -1;
 365
 366         /* For now, this function checks basic matcher attributes only;
 367          * later, this may be turned into one of multiple AST visitors. */
 368         if (node->cmd == SDB_CONNECTION_FETCH) {
 369                 conn_fetch_t *fetch = CONN_FETCH(node);
 370                 if ((fetch->type == SDB_HOST) && fetch->name) {
 371                         sdb_strbuf_sprintf(errbuf, "Unexpected STRING '%s'", fetch->name);
 372                         return -1;
 373                 }
 374                 if ((fetch->type != SDB_HOST) && (! fetch->name)) {
 375                         sdb_strbuf_sprintf(errbuf, "Missing %s name",
 376                                         SDB_STORE_TYPE_TO_NAME(fetch->type));
 377                         return -1;
 378                 }
 379                 if (fetch->filter)
 380                         filter = fetch->filter->matcher;
 381                 context = fetch->type;
 382         }
 383         else if (node->cmd == SDB_CONNECTION_LIST) {
 384                 if (CONN_LIST(node)->filter)
 385                         filter = CONN_LIST(node)->filter->matcher;
 386                 context = CONN_LIST(node)->type;
 387         }
 388         else if (node->cmd == SDB_CONNECTION_LOOKUP) {
 389                 if (CONN_LOOKUP(node)->matcher)
 390                         m = CONN_LOOKUP(node)->matcher->matcher;
 391                 if (CONN_LOOKUP(node)->filter)
 392                         filter = CONN_LOOKUP(node)->filter->matcher;
 393                 context = CONN_LOOKUP(node)->type;
 394         }
 395         else if ((node->cmd == SDB_CONNECTION_STORE_HOST)
 396                         || (node->cmd == SDB_CONNECTION_STORE_SERVICE)
 397                         || (node->cmd == SDB_CONNECTION_STORE_METRIC)
 398                         || (node->cmd == SDB_CONNECTION_STORE_ATTRIBUTE)) {
 399                 return 0;
 400         }
 401         else if (node->cmd == SDB_CONNECTION_TIMESERIES) {
 402                 return 0;
 403         }
 404         else {
 405                 sdb_strbuf_sprintf(errbuf,
 406                                 "Don't know how to analyze %s command (id=%#x)",
 407                                 SDB_CONN_MSGTYPE_TO_STRING(node->cmd), node->cmd);
 408                 return -1;
 409         }
 410
 411         if (context <= 0) {
 412                 sdb_strbuf_sprintf(errbuf, "Unable to determine the context "
 413                                 "(object type) for %s command (id=%#x)",
 414                                 SDB_CONN_MSGTYPE_TO_STRING(node->cmd), node->cmd);
 415                 return -1;
 416         }
 417         if (analyze_matcher(context, -1, m, errbuf))
 418                 status = -1;
 419         if (analyze_matcher(-1, -1, filter, errbuf))
 420                 status = -1;
 421         return status;
 422 } /* sdb_fe_analyze */
 423
 424 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
 425