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 */
28 #include "sysdb.h"
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"
36 #include <assert.h>
38 /*
39 * private helper functions
40 */
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 SDB_STORE_TYPE_TO_NAME(context));
49 } /* iter_error */
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 */
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 */
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 */
80 static int
81 analyze_expr(int context, sdb_store_expr_t *e, sdb_strbuf_t *errbuf)
82 {
83 if (! e)
84 return 0;
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 }
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 return 0;
100 sdb_strbuf_sprintf(errbuf, "Invalid expression %s.%s "
101 "in %s context",
102 SDB_STORE_TYPE_TO_NAME(e->data.data.integer),
103 EXPR_TO_STRING(e->left), SDB_STORE_TYPE_TO_NAME(context));
104 return -1;
106 case ATTR_VALUE:
107 case FIELD_VALUE:
108 case 0:
109 break;
111 default:
112 if (analyze_expr(context, e->left, errbuf))
113 return -1;
114 if (analyze_expr(context, e->right, errbuf))
115 return -1;
117 if ((e->left->data_type > 0) && (e->right->data_type > 0)) {
118 if (sdb_data_expr_type(e->type, e->left->data_type,
119 e->right->data_type) < 0) {
120 op_error(errbuf, e->type, e->left->data_type,
121 e->right->data_type);
122 return -1;
123 }
124 }
125 break;
126 }
127 return 0;
128 } /* analyze_expr */
130 static int
131 analyze_matcher(int context, int parent_type,
132 sdb_store_matcher_t *m, sdb_strbuf_t *errbuf)
133 {
134 if (! m)
135 return 0;
137 switch (m->type) {
138 case MATCHER_OR:
139 case MATCHER_AND:
140 assert(OP_M(m)->left && OP_M(m)->right);
141 if (analyze_matcher(context, m->type, OP_M(m)->left, errbuf))
142 return -1;
143 if (analyze_matcher(context, m->type, OP_M(m)->right, errbuf))
144 return -1;
145 break;
147 case MATCHER_NOT:
148 assert(UOP_M(m)->op);
149 if (analyze_matcher(context, m->type, UOP_M(m)->op, errbuf))
150 return -1;
151 break;
153 case MATCHER_ANY:
154 case MATCHER_ALL:
155 {
156 int type = -1;
157 int left_type = -1;
159 assert(ITER_M(m)->m);
161 if (ITER_M(m)->iter->type == TYPED_EXPR) {
162 type = (int)ITER_M(m)->iter->data.data.integer;
163 left_type = ITER_M(m)->iter->data_type;
164 }
165 else if (ITER_M(m)->iter->type == FIELD_VALUE) {
166 type = (int)ITER_M(m)->iter->data.data.integer;
167 /* element type of the field */
168 left_type = ITER_M(m)->iter->data_type & 0xff;
169 }
170 else {
171 iter_error(errbuf, m->type, ITER_M(m)->iter, context);
172 return -1;
173 }
175 if ((context != SDB_HOST)
176 && (context != SDB_SERVICE)
177 && (context != SDB_METRIC)) {
178 iter_error(errbuf, m->type, ITER_M(m)->iter, context);
179 return -1;
180 }
181 if (type == context) {
182 iter_error(errbuf, m->type, ITER_M(m)->iter, context);
183 return -1;
184 }
185 if ((type != SDB_SERVICE)
186 && (type != SDB_METRIC)
187 && (type != SDB_ATTRIBUTE)
188 && (type != SDB_FIELD_BACKEND)) {
189 iter_error(errbuf, m->type, ITER_M(m)->iter, context);
190 return -1;
191 }
192 if ((context == SDB_SERVICE) && (type == SDB_METRIC)) {
193 iter_error(errbuf, m->type, ITER_M(m)->iter, context);
194 return -1;
195 }
196 else if ((context == SDB_METRIC) && (type == SDB_SERVICE)) {
197 iter_error(errbuf, m->type, ITER_M(m)->iter, context);
198 return -1;
199 }
201 /* any ary operator will do but these are the once
202 * we currently support */
203 if ((ITER_M(m)->m->type != MATCHER_LT)
204 && (ITER_M(m)->m->type != MATCHER_LE)
205 && (ITER_M(m)->m->type != MATCHER_EQ)
206 && (ITER_M(m)->m->type != MATCHER_NE)
207 && (ITER_M(m)->m->type != MATCHER_GE)
208 && (ITER_M(m)->m->type != MATCHER_GT)
209 && (ITER_M(m)->m->type != MATCHER_REGEX)
210 && (ITER_M(m)->m->type != MATCHER_NREGEX)) {
211 iter_op_error(errbuf, m->type,
212 left_type, ITER_M(m)->m->type,
213 CMP_M(ITER_M(m)->m)->right->data_type);
214 return -1;
215 }
216 if ((left_type >= 0)
217 && (CMP_M(ITER_M(m)->m)->right->data_type >= 0)) {
218 if (left_type != CMP_M(ITER_M(m)->m)->right->data_type) {
219 iter_op_error(errbuf, m->type,
220 left_type, ITER_M(m)->m->type,
221 CMP_M(ITER_M(m)->m)->right->data_type);
222 return -1;
223 }
224 }
225 if (analyze_matcher(type, m->type, ITER_M(m)->m, errbuf))
226 return -1;
227 break;
228 }
230 case MATCHER_LT:
231 case MATCHER_LE:
232 case MATCHER_EQ:
233 case MATCHER_NE:
234 case MATCHER_GE:
235 case MATCHER_GT:
236 {
237 int left_type = -1;
239 assert(CMP_M(m)->right);
240 if ((parent_type == MATCHER_ALL)
241 || (parent_type == MATCHER_ANY)) {
242 assert(! CMP_M(m)->left);
243 }
244 else {
245 assert(CMP_M(m)->left);
246 left_type = CMP_M(m)->left->data_type;
247 }
249 if (analyze_expr(context, CMP_M(m)->left, errbuf))
250 return -1;
251 if (analyze_expr(context, CMP_M(m)->right, errbuf))
252 return -1;
254 if ((left_type > 0) && (CMP_M(m)->right->data_type > 0)) {
255 if (left_type == CMP_M(m)->right->data_type)
256 return 0;
257 cmp_error(errbuf, m->type, left_type,
258 CMP_M(m)->right->data_type);
259 return -1;
260 }
261 if ((left_type > 0) && (left_type & SDB_TYPE_ARRAY)) {
262 cmp_error(errbuf, m->type, left_type,
263 CMP_M(m)->right->data_type);
264 return -1;
265 }
266 if ((CMP_M(m)->right->data_type > 0)
267 && (CMP_M(m)->right->data_type & SDB_TYPE_ARRAY)) {
268 cmp_error(errbuf, m->type, left_type,
269 CMP_M(m)->right->data_type);
270 return -1;
271 }
272 break;
273 }
275 case MATCHER_IN:
276 case MATCHER_NIN:
277 if (analyze_expr(context, CMP_M(m)->left, errbuf))
278 return -1;
279 if (analyze_expr(context, CMP_M(m)->right, errbuf))
280 return -1;
282 /* the left operand may be a scalar or an array but the element
283 * type has to match */
284 if ((CMP_M(m)->right->data_type > 0)
285 && (! (CMP_M(m)->right->data_type & SDB_TYPE_ARRAY))) {
286 cmp_error(errbuf, m->type, CMP_M(m)->left->data_type,
287 CMP_M(m)->right->data_type);
288 return -1;
289 }
290 if ((CMP_M(m)->left->data_type > 0)
291 && (CMP_M(m)->right->data_type > 0)) {
292 if ((CMP_M(m)->left->data_type & 0xff)
293 != (CMP_M(m)->right->data_type & 0xff)) {
294 cmp_error(errbuf, m->type, CMP_M(m)->left->data_type,
295 CMP_M(m)->right->data_type);
296 return -1;
297 }
298 }
299 break;
301 case MATCHER_REGEX:
302 case MATCHER_NREGEX:
303 if (analyze_expr(context, CMP_M(m)->left, errbuf))
304 return -1;
305 if (analyze_expr(context, CMP_M(m)->right, errbuf))
306 return -1;
308 /* all types are supported for the left operand */
309 if ((CMP_M(m)->right->data_type > 0)
310 && (CMP_M(m)->right->data_type != SDB_TYPE_REGEX)
311 && (CMP_M(m)->right->data_type != SDB_TYPE_STRING)) {
312 cmp_error(errbuf, m->type, CMP_M(m)->left->data_type,
313 CMP_M(m)->right->data_type);
314 return -1;
315 }
316 break;
318 case MATCHER_ISNULL:
319 case MATCHER_ISNNULL:
320 if (analyze_expr(context, ISNULL_M(m)->expr, errbuf))
321 return -1;
322 break;
324 default:
325 sdb_strbuf_sprintf(errbuf, "Unknown matcher type %d", m->type);
326 return -1;
327 }
328 return 0;
329 } /* analyze_matcher */
331 /*
332 * public API
333 */
335 int
336 sdb_fe_analyze(sdb_conn_node_t *node, sdb_strbuf_t *errbuf)
337 {
338 sdb_store_matcher_t *m = NULL, *filter = NULL;
339 int context = -1;
340 int status = 0;
342 if (! node)
343 return -1;
345 /* For now, this function checks basic matcher attributes only;
346 * later, this may be turned into one of multiple AST visitors. */
347 if (node->cmd == SDB_CONNECTION_FETCH) {
348 conn_fetch_t *fetch = CONN_FETCH(node);
349 if ((fetch->type == SDB_HOST) && fetch->name) {
350 sdb_strbuf_sprintf(errbuf, "Unexpected STRING '%s'", fetch->name);
351 return -1;
352 }
353 if ((fetch->type != SDB_HOST) && (! fetch->name)) {
354 sdb_strbuf_sprintf(errbuf, "Missing %s name",
355 SDB_STORE_TYPE_TO_NAME(fetch->type));
356 return -1;
357 }
358 if (fetch->filter)
359 filter = fetch->filter->matcher;
360 context = fetch->type;
361 }
362 else if (node->cmd == SDB_CONNECTION_LIST) {
363 if (CONN_LIST(node)->filter)
364 filter = CONN_LIST(node)->filter->matcher;
365 context = CONN_LIST(node)->type;
366 }
367 else if (node->cmd == SDB_CONNECTION_LOOKUP) {
368 if (CONN_LOOKUP(node)->matcher)
369 m = CONN_LOOKUP(node)->matcher->matcher;
370 if (CONN_LOOKUP(node)->filter)
371 filter = CONN_LOOKUP(node)->filter->matcher;
372 context = CONN_LOOKUP(node)->type;
373 }
374 else if ((node->cmd == SDB_CONNECTION_STORE_HOST)
375 || (node->cmd == SDB_CONNECTION_STORE_SERVICE)
376 || (node->cmd == SDB_CONNECTION_STORE_METRIC)
377 || (node->cmd == SDB_CONNECTION_STORE_ATTRIBUTE)) {
378 return 0;
379 }
380 else if (node->cmd == SDB_CONNECTION_TIMESERIES) {
381 return 0;
382 }
383 else {
384 sdb_strbuf_sprintf(errbuf,
385 "Don't know how to analyze command %#x", node->cmd);
386 return -1;
387 }
389 if (analyze_matcher(context, -1, m, errbuf))
390 status = -1;
391 if (analyze_matcher(-1, -1, filter, errbuf))
392 status = -1;
393 return status;
394 } /* sdb_fe_analyze */
396 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */