1 /*
2 * SysDB - src/frontend/query.c
3 * Copyright (C) 2013-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.h"
31 #include "frontend/connection-private.h"
32 #include "parser/ast.h"
33 #include "parser/parser.h"
34 #include "utils/error.h"
35 #include "utils/proto.h"
36 #include "utils/strbuf.h"
38 #include <errno.h>
39 #include <string.h>
41 /*
42 * private helper functions
43 */
45 static int
46 list_tojson(sdb_store_obj_t *obj,
47 sdb_store_matcher_t __attribute__((unused)) *filter,
48 void *user_data)
49 {
50 sdb_store_json_formatter_t *f = user_data;
51 return sdb_store_json_emit(f, obj);
52 } /* list_tojson */
54 static int
55 lookup_tojson(sdb_store_obj_t *obj, sdb_store_matcher_t *filter,
56 void *user_data)
57 {
58 sdb_store_json_formatter_t *f = user_data;
59 return sdb_store_json_emit_full(f, obj, filter);
60 } /* lookup_tojson */
62 static int
63 query_exec(sdb_conn_t *conn, sdb_ast_node_t *ast)
64 {
65 sdb_store_query_t *q;
66 sdb_strbuf_t *buf;
67 int status;
69 q = sdb_store_query_prepare(ast);
70 if (! q) {
71 /* this shouldn't happen */
72 sdb_strbuf_sprintf(conn->errbuf, "failed to compile AST");
73 sdb_log(SDB_LOG_ERR, "frontend: failed to compile AST");
74 return -1;
75 }
77 buf = sdb_strbuf_create(1024);
78 if (! buf) {
79 sdb_strbuf_sprintf(conn->errbuf, "Out of memory");
80 sdb_object_deref(SDB_OBJ(q));
81 return -1;
82 }
83 status = sdb_store_query_execute(q, buf, conn->errbuf);
84 if (status < 0) {
85 char query[conn->cmd_len + 1];
86 strncpy(query, sdb_strbuf_string(conn->buf), conn->cmd_len);
87 query[sizeof(query) - 1] = '\0';
88 sdb_log(SDB_LOG_ERR, "frontend: failed to execute query '%s'", query);
89 }
90 else
91 sdb_connection_send(conn, status,
92 (uint32_t)sdb_strbuf_len(buf), sdb_strbuf_string(buf));
94 sdb_strbuf_destroy(buf);
95 sdb_object_deref(SDB_OBJ(q));
96 return status < 0 ? status : 0;
97 } /* query_exec */
99 /*
100 * public API
101 */
103 int
104 sdb_fe_query(sdb_conn_t *conn)
105 {
106 sdb_llist_t *parsetree;
107 sdb_ast_node_t *ast = NULL;
108 int status = 0;
110 if ((! conn) || (conn->cmd != SDB_CONNECTION_QUERY))
111 return -1;
113 parsetree = sdb_parser_parse(sdb_strbuf_string(conn->buf),
114 (int)conn->cmd_len, conn->errbuf);
115 if (! parsetree) {
116 char query[conn->cmd_len + 1];
117 strncpy(query, sdb_strbuf_string(conn->buf), conn->cmd_len);
118 query[sizeof(query) - 1] = '\0';
119 sdb_log(SDB_LOG_ERR, "frontend: Failed to parse query '%s': %s",
120 query, sdb_strbuf_string(conn->errbuf));
121 return -1;
122 }
124 switch (sdb_llist_len(parsetree)) {
125 case 0:
126 /* skipping empty command; send back an empty reply */
127 sdb_connection_send(conn, SDB_CONNECTION_DATA, 0, NULL);
128 break;
129 case 1:
130 ast = SDB_AST_NODE(sdb_llist_get(parsetree, 0));
131 break;
133 default:
134 {
135 char query[conn->cmd_len + 1];
136 strncpy(query, sdb_strbuf_string(conn->buf), conn->cmd_len);
137 query[sizeof(query) - 1] = '\0';
138 sdb_log(SDB_LOG_WARNING, "frontend: Ignoring %zu command%s "
139 "in multi-statement query '%s'",
140 sdb_llist_len(parsetree) - 1,
141 sdb_llist_len(parsetree) == 2 ? "" : "s",
142 query);
143 ast = SDB_AST_NODE(sdb_llist_get(parsetree, 0));
144 }
145 }
147 if (ast) {
148 status = query_exec(conn, ast);
149 sdb_object_deref(SDB_OBJ(ast));
150 }
151 sdb_llist_destroy(parsetree);
152 return status;
153 } /* sdb_fe_query */
155 int
156 sdb_fe_fetch(sdb_conn_t *conn)
157 {
158 char name[conn->cmd_len + 1];
159 uint32_t type;
161 if ((! conn) || (conn->cmd != SDB_CONNECTION_FETCH))
162 return -1;
164 if (conn->cmd_len < sizeof(uint32_t)) {
165 sdb_log(SDB_LOG_ERR, "frontend: Invalid command length %d for "
166 "FETCH command", conn->cmd_len);
167 sdb_strbuf_sprintf(conn->errbuf, "FETCH: Invalid command length %d",
168 conn->cmd_len);
169 return -1;
170 }
172 sdb_proto_unmarshal_int32(SDB_STRBUF_STR(conn->buf), &type);
173 strncpy(name, sdb_strbuf_string(conn->buf) + sizeof(uint32_t),
174 conn->cmd_len - sizeof(uint32_t));
175 name[sizeof(name) - 1] = '\0';
176 /* TODO: support other types besides hosts */
177 return sdb_fe_exec_fetch(conn, (int)type, name, NULL, /* filter = */ NULL);
178 } /* sdb_fe_fetch */
180 int
181 sdb_fe_list(sdb_conn_t *conn)
182 {
183 uint32_t type = SDB_HOST;
185 if ((! conn) || (conn->cmd != SDB_CONNECTION_LIST))
186 return -1;
188 if (conn->cmd_len == sizeof(uint32_t))
189 sdb_proto_unmarshal_int32(SDB_STRBUF_STR(conn->buf), &type);
190 else if (conn->cmd_len) {
191 sdb_log(SDB_LOG_ERR, "frontend: Invalid command length %d for "
192 "LIST command", conn->cmd_len);
193 sdb_strbuf_sprintf(conn->errbuf, "LIST: Invalid command length %d",
194 conn->cmd_len);
195 return -1;
196 }
197 return sdb_fe_exec_list(conn, (int)type, /* filter = */ NULL);
198 } /* sdb_fe_list */
200 int
201 sdb_fe_lookup(sdb_conn_t *conn)
202 {
203 sdb_store_matcher_t *m;
204 const char *matcher;
205 size_t matcher_len;
207 uint32_t type;
208 int status;
210 conn_matcher_t m_node = {
211 { SDB_OBJECT_INIT, SDB_CONNECTION_MATCHER }, NULL
212 };
213 conn_lookup_t node = {
214 { SDB_OBJECT_INIT, SDB_CONNECTION_LOOKUP },
215 -1, &m_node, NULL
216 };
218 if ((! conn) || (conn->cmd != SDB_CONNECTION_LOOKUP))
219 return -1;
221 if (conn->cmd_len < sizeof(uint32_t)) {
222 sdb_log(SDB_LOG_ERR, "frontend: Invalid command length %d for "
223 "LOOKUP command", conn->cmd_len);
224 sdb_strbuf_sprintf(conn->errbuf, "LOOKUP: Invalid command length %d",
225 conn->cmd_len);
226 return -1;
227 }
228 sdb_proto_unmarshal_int32(SDB_STRBUF_STR(conn->buf), &type);
230 matcher = sdb_strbuf_string(conn->buf) + sizeof(uint32_t);
231 matcher_len = conn->cmd_len - sizeof(uint32_t);
232 m = sdb_fe_parse_matcher(matcher, (int)matcher_len, conn->errbuf);
233 if (! m) {
234 char expr[matcher_len + 1];
235 strncpy(expr, matcher, sizeof(expr));
236 expr[sizeof(expr) - 1] = '\0';
237 sdb_log(SDB_LOG_ERR, "frontend: Failed to parse "
238 "lookup condition '%s': %s", expr,
239 sdb_strbuf_string(conn->errbuf));
240 return -1;
241 }
243 node.type = (int)type;
244 m_node.matcher = m;
246 /* run analyzer separately; parse_matcher is missing
247 * the right context to do so */
248 if (sdb_fe_analyze(SDB_CONN_NODE(&node), conn->errbuf)) {
249 char expr[matcher_len + 1];
250 char err[sdb_strbuf_len(conn->errbuf) + sizeof(expr) + 64];
251 strncpy(expr, matcher, sizeof(expr));
252 expr[sizeof(expr) - 1] = '\0';
253 snprintf(err, sizeof(err), "Failed to parse "
254 "lookup condition '%s': %s", expr,
255 sdb_strbuf_string(conn->errbuf));
256 sdb_strbuf_sprintf(conn->errbuf, "%s", err);
257 status = -1;
258 }
259 else
260 status = sdb_fe_exec_lookup(conn, (int)type, m, /* filter = */ NULL);
261 sdb_object_deref(SDB_OBJ(m));
262 return status;
263 } /* sdb_fe_lookup */
265 /*
266 * TODO: let the functions above build an AST; then drop sdb_fe_exec_*.
267 */
269 int
270 sdb_fe_exec_fetch(sdb_conn_t *conn, int type,
271 const char *hostname, const char *name, sdb_store_matcher_t *filter)
272 {
273 uint32_t res_type = htonl(SDB_CONNECTION_FETCH);
275 sdb_store_obj_t *host;
276 sdb_store_obj_t *obj;
278 sdb_store_json_formatter_t *f;
279 sdb_strbuf_t *buf;
281 if ((! hostname) || ((type == SDB_HOST) && name)
282 || ((type != SDB_HOST) && (! name))) {
283 /* This is a programming error, not something the client did wrong */
284 sdb_strbuf_sprintf(conn->errbuf, "INTERNAL ERROR: invalid "
285 "arguments to sdb_fe_exec_fetch(%s, %s, %s)",
286 SDB_STORE_TYPE_TO_NAME(type), hostname, name);
287 return -1;
288 }
289 if (type == SDB_HOST)
290 name = hostname;
292 host = sdb_store_get_host(hostname);
293 if ((! host) || (filter
294 && (! sdb_store_matcher_matches(filter, host, NULL)))) {
295 sdb_strbuf_sprintf(conn->errbuf, "Failed to fetch %s %s: "
296 "host %s not found", SDB_STORE_TYPE_TO_NAME(type),
297 name, hostname);
298 sdb_object_deref(SDB_OBJ(host));
299 return -1;
300 }
301 if (type == SDB_HOST) {
302 obj = host;
303 }
304 else {
305 obj = sdb_store_get_child(host, type, name);
306 if ((! obj) || (filter
307 && (! sdb_store_matcher_matches(filter, obj, NULL)))) {
308 sdb_strbuf_sprintf(conn->errbuf, "Failed to fetch %s %s.%s: "
309 "%s not found", SDB_STORE_TYPE_TO_NAME(type),
310 hostname, name, name);
311 if (obj)
312 sdb_object_deref(SDB_OBJ(obj));
313 sdb_object_deref(SDB_OBJ(host));
314 return -1;
315 }
316 sdb_object_deref(SDB_OBJ(host));
317 }
318 host = NULL;
320 buf = sdb_strbuf_create(1024);
321 if (! buf) {
322 char errbuf[1024];
323 sdb_log(SDB_LOG_ERR, "frontend: Failed to create "
324 "buffer to handle FETCH command: %s",
325 sdb_strerror(errno, errbuf, sizeof(errbuf)));
327 sdb_strbuf_sprintf(conn->errbuf, "Out of memory");
328 sdb_strbuf_destroy(buf);
329 sdb_object_deref(SDB_OBJ(obj));
330 return -1;
331 }
332 f = sdb_store_json_formatter(buf, type, /* flags = */ 0);
333 if (! f) {
334 char errbuf[1024];
335 sdb_log(SDB_LOG_ERR, "frontend: Failed to create "
336 "JSON formatter to handle FETCH command: %s",
337 sdb_strerror(errno, errbuf, sizeof(errbuf)));
339 sdb_strbuf_sprintf(conn->errbuf, "Out of memory");
340 sdb_strbuf_destroy(buf);
341 sdb_object_deref(SDB_OBJ(obj));
342 return -1;
343 }
345 sdb_strbuf_memcpy(buf, &res_type, sizeof(uint32_t));
346 if (sdb_store_json_emit_full(f, obj, filter)) {
347 sdb_log(SDB_LOG_ERR, "frontend: Failed to serialize "
348 "%s %s.%s to JSON", SDB_STORE_TYPE_TO_NAME(type),
349 hostname, name);
350 sdb_strbuf_sprintf(conn->errbuf, "Out of memory");
351 sdb_strbuf_destroy(buf);
352 free(f);
353 sdb_object_deref(SDB_OBJ(obj));
354 return -1;
355 }
356 sdb_store_json_finish(f);
358 sdb_connection_send(conn, SDB_CONNECTION_DATA,
359 (uint32_t)sdb_strbuf_len(buf), sdb_strbuf_string(buf));
360 sdb_strbuf_destroy(buf);
361 free(f);
362 sdb_object_deref(SDB_OBJ(obj));
363 return 0;
364 } /* sdb_fe_exec_fetch */
366 int
367 sdb_fe_exec_list(sdb_conn_t *conn, int type, sdb_store_matcher_t *filter)
368 {
369 uint32_t res_type = htonl(SDB_CONNECTION_LIST);
371 sdb_store_json_formatter_t *f;
372 sdb_strbuf_t *buf;
374 buf = sdb_strbuf_create(1024);
375 if (! buf) {
376 char errbuf[1024];
377 sdb_log(SDB_LOG_ERR, "frontend: Failed to create "
378 "buffer to handle LIST command: %s",
379 sdb_strerror(errno, errbuf, sizeof(errbuf)));
381 sdb_strbuf_sprintf(conn->errbuf, "Out of memory");
382 sdb_strbuf_destroy(buf);
383 return -1;
384 }
385 f = sdb_store_json_formatter(buf, type, SDB_WANT_ARRAY);
386 if (! f) {
387 char errbuf[1024];
388 sdb_log(SDB_LOG_ERR, "frontend: Failed to create "
389 "JSON formatter to handle LIST command: %s",
390 sdb_strerror(errno, errbuf, sizeof(errbuf)));
392 sdb_strbuf_sprintf(conn->errbuf, "Out of memory");
393 sdb_strbuf_destroy(buf);
394 return -1;
395 }
397 sdb_strbuf_memcpy(buf, &res_type, sizeof(uint32_t));
398 if (sdb_store_scan(type, /* m = */ NULL, filter, list_tojson, f)) {
399 sdb_log(SDB_LOG_ERR, "frontend: Failed to serialize "
400 "store to JSON");
401 sdb_strbuf_sprintf(conn->errbuf, "Out of memory");
402 sdb_strbuf_destroy(buf);
403 free(f);
404 return -1;
405 }
406 sdb_store_json_finish(f);
408 sdb_connection_send(conn, SDB_CONNECTION_DATA,
409 (uint32_t)sdb_strbuf_len(buf), sdb_strbuf_string(buf));
410 sdb_strbuf_destroy(buf);
411 free(f);
412 return 0;
413 } /* sdb_fe_exec_list */
415 int
416 sdb_fe_exec_lookup(sdb_conn_t *conn, int type,
417 sdb_store_matcher_t *m, sdb_store_matcher_t *filter)
418 {
419 uint32_t res_type = htonl(SDB_CONNECTION_LOOKUP);
421 sdb_store_json_formatter_t *f;
422 sdb_strbuf_t *buf;
424 buf = sdb_strbuf_create(1024);
425 if (! buf) {
426 char errbuf[1024];
427 sdb_log(SDB_LOG_ERR, "frontend: Failed to create "
428 "buffer to handle LOOKUP command: %s",
429 sdb_strerror(errno, errbuf, sizeof(errbuf)));
431 sdb_strbuf_sprintf(conn->errbuf, "Out of memory");
432 return -1;
433 }
434 f = sdb_store_json_formatter(buf, type, SDB_WANT_ARRAY);
435 if (! f) {
436 char errbuf[1024];
437 sdb_log(SDB_LOG_ERR, "frontend: Failed to create "
438 "JSON formatter to handle LOOKUP command: %s",
439 sdb_strerror(errno, errbuf, sizeof(errbuf)));
441 sdb_strbuf_sprintf(conn->errbuf, "Out of memory");
442 sdb_strbuf_destroy(buf);
443 return -1;
444 }
446 sdb_strbuf_memcpy(buf, &res_type, sizeof(uint32_t));
448 if (sdb_store_scan(type, m, filter, lookup_tojson, f)) {
449 sdb_log(SDB_LOG_ERR, "frontend: Failed to lookup %ss",
450 SDB_STORE_TYPE_TO_NAME(type));
451 sdb_strbuf_sprintf(conn->errbuf, "Failed to lookup %ss",
452 SDB_STORE_TYPE_TO_NAME(type));
453 sdb_strbuf_destroy(buf);
454 free(f);
455 return -1;
456 }
457 sdb_store_json_finish(f);
459 sdb_connection_send(conn, SDB_CONNECTION_DATA,
460 (uint32_t)sdb_strbuf_len(buf), sdb_strbuf_string(buf));
461 sdb_strbuf_destroy(buf);
462 free(f);
463 return 0;
464 } /* sdb_fe_exec_lookup */
466 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */