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, int oper, int context)
  44 {
  45         sdb_strbuf_sprintf(errbuf, "Cannot use %s %s in %s context",
  46                         MATCHER_SYM(op), SDB_STORE_TYPE_TO_NAME(oper),
  47                         SDB_STORE_TYPE_TO_NAME(context));
  48 } /* iter_error */
  49
  50 static void
  51 iter_array_error(sdb_strbuf_t *errbuf, int op,
  52                 int array_type, int cmp, int value_type)
  53 {
  54         sdb_strbuf_sprintf(errbuf, "Invalid array iterator %s %s %s %s",
  55                         MATCHER_SYM(op), SDB_TYPE_TO_STRING(array_type),
  56                         MATCHER_SYM(cmp), SDB_TYPE_TO_STRING(value_type));
  57         if ((array_type & 0xff) != value_type)
  58                 sdb_strbuf_append(errbuf, " (type mismatch)");
  59         else
  60                 sdb_strbuf_append(errbuf, " (invalid operator)");
  61 } /* iter_array_error */
  62
  63 static void
  64 cmp_error(sdb_strbuf_t *errbuf, int op, int left, int right)
  65 {
  66         sdb_strbuf_sprintf(errbuf, "Invalid operator %s for types %s and %s",
  67                         MATCHER_SYM(op), SDB_TYPE_TO_STRING(left),
  68                         SDB_TYPE_TO_STRING(right));
  69 } /* cmp_error */
  70
  71 static int
  72 analyze_matcher(int context, sdb_store_matcher_t *m, sdb_strbuf_t *errbuf)
  73 {
  74         if (! m)
  75                 return 0;
  76
  77         switch (m->type) {
  78                 case MATCHER_OR:
  79                 case MATCHER_AND:
  80                         assert(OP_M(m)->left && OP_M(m)->right);
  81                         if (analyze_matcher(context, OP_M(m)->left, errbuf))
  82                                 return -1;
  83                         if (analyze_matcher(context, OP_M(m)->right, errbuf))
  84                                 return -1;
  85                         break;
  86
  87                 case MATCHER_NOT:
  88                         assert(UOP_M(m)->op);
  89                         if (analyze_matcher(context, UOP_M(m)->op, errbuf))
  90                                 return -1;
  91                         break;
  92
  93                 case MATCHER_ANY:
  94                 case MATCHER_ALL:
  95                         assert(ITER_M(m)->m);
  96                         if ((context != SDB_HOST)
  97                                         && (context != SDB_SERVICE)
  98                                         && (context != SDB_METRIC)) {
  99                                 iter_error(errbuf, m->type, ITER_M(m)->type, context);
 100                                 return -1;
 101                         }
 102                         if (ITER_M(m)->type == context) {
 103                                 iter_error(errbuf, m->type, ITER_M(m)->type, context);
 104                                 return -1;
 105                         }
 106                         if ((ITER_M(m)->type != SDB_SERVICE)
 107                                         && (ITER_M(m)->type != SDB_METRIC)
 108                                         && (ITER_M(m)->type != SDB_ATTRIBUTE)
 109                                         && (ITER_M(m)->type != SDB_FIELD_BACKEND)) {
 110                                 iter_error(errbuf, m->type, ITER_M(m)->type, context);
 111                                 return -1;
 112                         }
 113                         if ((context == SDB_SERVICE)
 114                                         && (ITER_M(m)->type == SDB_METRIC)) {
 115                                 iter_error(errbuf, m->type, ITER_M(m)->type, context);
 116                                 return -1;
 117                         }
 118                         else if ((context == SDB_METRIC)
 119                                         && (ITER_M(m)->type == SDB_SERVICE)) {
 120                                 iter_error(errbuf, m->type, ITER_M(m)->type, context);
 121                                 return -1;
 122                         }
 123                         if (ITER_M(m)->type == SDB_FIELD_BACKEND) {
 124                                 /* array iterators only support simple comparison atm */
 125                                 if ((ITER_M(m)->m->type != MATCHER_LT)
 126                                                 && (ITER_M(m)->m->type != MATCHER_LE)
 127                                                 && (ITER_M(m)->m->type != MATCHER_EQ)
 128                                                 && (ITER_M(m)->m->type != MATCHER_NE)
 129                                                 && (ITER_M(m)->m->type != MATCHER_GE)
 130                                                 && (ITER_M(m)->m->type != MATCHER_GT)
 131                                                 && (ITER_M(m)->m->type != MATCHER_REGEX)
 132                                                 && (ITER_M(m)->m->type != MATCHER_NREGEX)) {
 133                                         iter_array_error(errbuf, m->type,
 134                                                         CMP_M(ITER_M(m)->m)->left->data_type,
 135                                                         ITER_M(m)->m->type,
 136                                                         CMP_M(ITER_M(m)->m)->right->data_type);
 137                                         return -1;
 138                                 }
 139                                 if (CMP_M(ITER_M(m)->m)->right->data_type < 0)
 140                                         return 0; /* skip further type checks */
 141                                 if (CMP_M(ITER_M(m)->m)->right->data_type & SDB_TYPE_ARRAY) {
 142                                         iter_array_error(errbuf, m->type,
 143                                                         CMP_M(ITER_M(m)->m)->left->data_type,
 144                                                         ITER_M(m)->m->type,
 145                                                         CMP_M(ITER_M(m)->m)->right->data_type);
 146                                         return -1;
 147                                 }
 148                                 if ((CMP_M(ITER_M(m)->m)->left->data_type & 0xff)
 149                                                 != CMP_M(ITER_M(m)->m)->right->data_type) {
 150                                         iter_array_error(errbuf, m->type,
 151                                                         CMP_M(ITER_M(m)->m)->left->data_type,
 152                                                         ITER_M(m)->m->type,
 153                                                         CMP_M(ITER_M(m)->m)->right->data_type);
 154                                         return -1;
 155                                 }
 156                         }
 157                         else if (analyze_matcher(ITER_M(m)->type, ITER_M(m)->m, errbuf))
 158                                 return -1;
 159                         break;
 160
 161                 case MATCHER_LT:
 162                 case MATCHER_LE:
 163                 case MATCHER_EQ:
 164                 case MATCHER_NE:
 165                 case MATCHER_GE:
 166                 case MATCHER_GT:
 167                         assert(CMP_M(m)->left && CMP_M(m)->right);
 168                         if ((CMP_M(m)->left->data_type > 0)
 169                                         && (CMP_M(m)->left->data_type & SDB_TYPE_ARRAY)) {
 170                                 cmp_error(errbuf, m->type, CMP_M(m)->left->data_type,
 171                                                 CMP_M(m)->right->data_type);
 172                                 return -1;
 173                         }
 174                         if ((CMP_M(m)->right->data_type > 0)
 175                                         && (CMP_M(m)->right->data_type & SDB_TYPE_ARRAY)) {
 176                                 cmp_error(errbuf, m->type, CMP_M(m)->left->data_type,
 177                                                 CMP_M(m)->right->data_type);
 178                                 return -1;
 179                         }
 180                         break;
 181
 182                 case MATCHER_IN:
 183                         if ((CMP_M(m)->left->data_type > 0)
 184                                         && (CMP_M(m)->left->data_type & SDB_TYPE_ARRAY)) {
 185                                 cmp_error(errbuf, m->type, CMP_M(m)->left->data_type,
 186                                                 CMP_M(m)->right->data_type);
 187                                 return -1;
 188                         }
 189                         if ((CMP_M(m)->right->data_type > 0)
 190                                         && (! (CMP_M(m)->right->data_type & SDB_TYPE_ARRAY))) {
 191                                 cmp_error(errbuf, m->type, CMP_M(m)->left->data_type,
 192                                                 CMP_M(m)->right->data_type);
 193                                 return -1;
 194                         }
 195                         break;
 196
 197                 case MATCHER_REGEX:
 198                 case MATCHER_NREGEX:
 199                         /* all types are supported for the left operand */
 200                         if ((CMP_M(m)->right->data_type > 0)
 201                                         && (CMP_M(m)->right->data_type != SDB_TYPE_REGEX)
 202                                         && (CMP_M(m)->right->data_type != SDB_TYPE_STRING)) {
 203                                 cmp_error(errbuf, m->type, CMP_M(m)->left->data_type,
 204                                                 CMP_M(m)->right->data_type);
 205                                 return -1;
 206                         }
 207                         break;
 208
 209                 case MATCHER_ISNULL:
 210                 case MATCHER_ISNNULL:
 211                         break;
 212
 213                 default:
 214                         sdb_strbuf_sprintf(errbuf, "Unknown matcher type %d", m->type);
 215                         return -1;
 216         }
 217         return 0;
 218 } /* analyze_matcher */
 219
 220 /*
 221  * public API
 222  */
 223
 224 int
 225 sdb_fe_analyze(sdb_conn_node_t *node, sdb_strbuf_t *errbuf)
 226 {
 227         sdb_store_matcher_t *m = NULL, *filter = NULL;
 228         int context = -1;
 229         int status = 0;
 230
 231         if (! node)
 232                 return -1;
 233
 234         /* For now, this function checks basic matcher attributes only;
 235          * later, this may be turned into one of multiple AST visitors. */
 236         if (node->cmd == SDB_CONNECTION_FETCH) {
 237                 conn_fetch_t *fetch = CONN_FETCH(node);
 238                 if ((fetch->type == SDB_HOST) && fetch->name) {
 239                         sdb_strbuf_sprintf(errbuf, "Unexpected STRING '%s'", fetch->name);
 240                         return -1;
 241                 }
 242                 if ((fetch->type != SDB_HOST) && (! fetch->name)) {
 243                         sdb_strbuf_sprintf(errbuf, "Missing %s name",
 244                                         SDB_STORE_TYPE_TO_NAME(fetch->type));
 245                         return -1;
 246                 }
 247                 if (fetch->filter)
 248                         filter = fetch->filter->matcher;
 249                 context = fetch->type;
 250         }
 251         else if (node->cmd == SDB_CONNECTION_LIST) {
 252                 if (CONN_LIST(node)->filter)
 253                         filter = CONN_LIST(node)->filter->matcher;
 254                 context = CONN_LIST(node)->type;
 255         }
 256         else if (node->cmd == SDB_CONNECTION_LOOKUP) {
 257                 if (CONN_LOOKUP(node)->matcher)
 258                         m = CONN_LOOKUP(node)->matcher->matcher;
 259                 if (CONN_LOOKUP(node)->filter)
 260                         filter = CONN_LOOKUP(node)->filter->matcher;
 261                 context = CONN_LOOKUP(node)->type;
 262         }
 263         else if (node->cmd == SDB_CONNECTION_TIMESERIES)
 264                 return 0;
 265         else
 266                 return -1;
 267
 268         if (analyze_matcher(context, m, errbuf))
 269                 status = -1;
 270         if (analyze_matcher(-1, filter, errbuf))
 271                 status = -1;
 272         return status;
 273 } /* sdb_fe_analyze */
 274
 275 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
 276