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, 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 */
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 */
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 */
71 static int
72 analyze_matcher(int context, sdb_store_matcher_t *m, sdb_strbuf_t *errbuf)
73 {
74 if (! m)
75 return 0;
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;
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;
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;
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)->right->data_type > 0)
170 && (CMP_M(m)->left->data_type == CMP_M(m)->right->data_type))
171 return 0;
172 if ((CMP_M(m)->left->data_type > 0)
173 && (CMP_M(m)->left->data_type & SDB_TYPE_ARRAY)) {
174 cmp_error(errbuf, m->type, CMP_M(m)->left->data_type,
175 CMP_M(m)->right->data_type);
176 return -1;
177 }
178 if ((CMP_M(m)->right->data_type > 0)
179 && (CMP_M(m)->right->data_type & SDB_TYPE_ARRAY)) {
180 cmp_error(errbuf, m->type, CMP_M(m)->left->data_type,
181 CMP_M(m)->right->data_type);
182 return -1;
183 }
184 break;
186 case MATCHER_IN:
187 if ((CMP_M(m)->left->data_type > 0)
188 && (CMP_M(m)->left->data_type & SDB_TYPE_ARRAY)) {
189 cmp_error(errbuf, m->type, CMP_M(m)->left->data_type,
190 CMP_M(m)->right->data_type);
191 return -1;
192 }
193 if ((CMP_M(m)->right->data_type > 0)
194 && (! (CMP_M(m)->right->data_type & SDB_TYPE_ARRAY))) {
195 cmp_error(errbuf, m->type, CMP_M(m)->left->data_type,
196 CMP_M(m)->right->data_type);
197 return -1;
198 }
199 break;
201 case MATCHER_REGEX:
202 case MATCHER_NREGEX:
203 /* all types are supported for the left operand */
204 if ((CMP_M(m)->right->data_type > 0)
205 && (CMP_M(m)->right->data_type != SDB_TYPE_REGEX)
206 && (CMP_M(m)->right->data_type != SDB_TYPE_STRING)) {
207 cmp_error(errbuf, m->type, CMP_M(m)->left->data_type,
208 CMP_M(m)->right->data_type);
209 return -1;
210 }
211 break;
213 case MATCHER_ISNULL:
214 case MATCHER_ISNNULL:
215 break;
217 default:
218 sdb_strbuf_sprintf(errbuf, "Unknown matcher type %d", m->type);
219 return -1;
220 }
221 return 0;
222 } /* analyze_matcher */
224 /*
225 * public API
226 */
228 int
229 sdb_fe_analyze(sdb_conn_node_t *node, sdb_strbuf_t *errbuf)
230 {
231 sdb_store_matcher_t *m = NULL, *filter = NULL;
232 int context = -1;
233 int status = 0;
235 if (! node)
236 return -1;
238 /* For now, this function checks basic matcher attributes only;
239 * later, this may be turned into one of multiple AST visitors. */
240 if (node->cmd == SDB_CONNECTION_FETCH) {
241 conn_fetch_t *fetch = CONN_FETCH(node);
242 if ((fetch->type == SDB_HOST) && fetch->name) {
243 sdb_strbuf_sprintf(errbuf, "Unexpected STRING '%s'", fetch->name);
244 return -1;
245 }
246 if ((fetch->type != SDB_HOST) && (! fetch->name)) {
247 sdb_strbuf_sprintf(errbuf, "Missing %s name",
248 SDB_STORE_TYPE_TO_NAME(fetch->type));
249 return -1;
250 }
251 if (fetch->filter)
252 filter = fetch->filter->matcher;
253 context = fetch->type;
254 }
255 else if (node->cmd == SDB_CONNECTION_LIST) {
256 if (CONN_LIST(node)->filter)
257 filter = CONN_LIST(node)->filter->matcher;
258 context = CONN_LIST(node)->type;
259 }
260 else if (node->cmd == SDB_CONNECTION_LOOKUP) {
261 if (CONN_LOOKUP(node)->matcher)
262 m = CONN_LOOKUP(node)->matcher->matcher;
263 if (CONN_LOOKUP(node)->filter)
264 filter = CONN_LOOKUP(node)->filter->matcher;
265 context = CONN_LOOKUP(node)->type;
266 }
267 else if (node->cmd == SDB_CONNECTION_TIMESERIES)
268 return 0;
269 else
270 return -1;
272 if (analyze_matcher(context, m, errbuf))
273 status = -1;
274 if (analyze_matcher(-1, filter, errbuf))
275 status = -1;
276 return status;
277 } /* sdb_fe_analyze */
279 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */