1 /* recdb.c - recursive/record database implementation
2 * Copyright 2000-2004 srvx Development Team
4 * This file is part of srvx.
6 * srvx is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with srvx; if not, write to the Free Software Foundation,
18 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
27 #ifdef HAVE_SYS_MMAN_H
30 #ifdef HAVE_SYS_STAT_H
35 #define MMAP_MAP_LENGTH (getpagesize()*1024)
37 /* file format (grammar in Backus-Naur Form):
40 * record := qstring [ '=' ] ( qstring | object | stringlist ) ';'
41 * qstring := '"' ( [^\\] | ('\\' [\\n]) )* '"'
42 * object := '{' record* '}'
43 * stringlist := '(' [ qstring [',' qstring]* ] ')'
47 /* when a database or object is read from disk, it is represented as
48 * a dictionary object, keys are names (what's left of the '=') and
49 * values are 'struct record_data's
52 struct recdb_context {
63 typedef struct recdb_file {
65 FILE *f; /* For RECDB_FILE, RECDB_MMAP */
66 char *s; /* For RECDB_STRING, RECDB_MMAP */
67 enum recdb_filetype type;
70 struct recdb_context ctx;
74 typedef struct recdb_outfile {
75 FILE *f; /* For RECDB_FILE, RECDB_MMAP */
76 char *s; /* For RECDB_STRING, RECDB_MMAP */
78 struct { /* For RECDB_STRING */
82 struct { /* For RECDB_MMAP */
87 enum recdb_filetype type;
96 static int mmap_error;
102 #define ABORT(recdb, code, ch) longjmp((recdb)->env, ((code) << 8) | (ch))
105 ABORT(RECDB *recdb, int code, unsigned char ch) {
106 longjmp(recdb->env, code << 8 | ch);
116 EXPECTED_START_RECORD_DATA,
121 static void parse_record_int(RECDB *recdb, char **pname, struct record_data **prd);
123 /* allocation functions */
125 #define alloc_record_data_int() malloc(sizeof(struct record_data))
128 alloc_record_data_qstring(const char *string)
130 struct record_data *rd;
131 rd = alloc_record_data_int();
132 SET_RECORD_QSTRING(rd, string);
137 alloc_record_data_object(dict_t obj)
139 struct record_data *rd;
140 rd = alloc_record_data_int();
141 SET_RECORD_OBJECT(rd, obj);
146 alloc_record_data_string_list(struct string_list *slist)
148 struct record_data *rd;
149 rd = alloc_record_data_int();
150 SET_RECORD_STRING_LIST(rd, slist);
155 alloc_string_list(int size)
157 struct string_list *slist;
158 slist = malloc(sizeof(struct string_list));
161 slist->list = slist->size ? malloc(size*sizeof(char*)) : NULL;
168 dict_t db = dict_new();
169 dict_set_free_data(db, free_record_data);
173 /* misc. operations */
176 string_list_append(struct string_list *slist, char *string)
178 if (slist->used == slist->size) {
181 slist->list = realloc(slist->list, slist->size*sizeof(char*));
184 slist->list = malloc(slist->size*sizeof(char*));
187 slist->list[slist->used++] = string;
191 string_list_copy(struct string_list *slist)
193 struct string_list *new_list;
195 new_list = alloc_string_list(slist->size);
196 new_list->used = slist->used;
197 for (i=0; i<new_list->used; i++) {
198 new_list->list[i] = strdup(slist->list[i]);
203 int slist_compare_two(const void *pa, const void *pb)
205 return irccasecmp(*(const char**)pa, *(const char **)pb);
209 string_list_sort(struct string_list *slist)
211 qsort(slist->list, slist->used, sizeof(slist->list[0]), slist_compare_two);
215 database_get_path(dict_t db, const char *path)
217 char *new_path = strdup(path), *orig_path = new_path;
219 struct record_data *rd;
221 for (part=new_path; *new_path; new_path++) {
222 if (*new_path != '/') continue;
225 rd = dict_find(db, part, NULL);
226 if (!rd || rd->type != RECDB_OBJECT) {
235 rd = dict_find(db, part, NULL);
241 database_get_data(dict_t db, const char *path, enum recdb_type type)
243 struct record_data *rd = database_get_path(db, path);
244 return (rd && rd->type == type) ? rd->d.whatever : NULL;
250 free_string_list(struct string_list *slist)
255 for (i=0; i<slist->used; i++)
256 free(slist->list[i]);
262 free_record_data(void *rdata)
264 struct record_data *r = rdata;
266 case RECDB_INVALID: break;
267 case RECDB_QSTRING: free(r->d.qstring); break;
268 case RECDB_OBJECT: dict_delete(r->d.object); break;
269 case RECDB_STRING_LIST: free_string_list(r->d.slist); break;
274 /* parse functions */
279 switch (recdb->type) {
281 return feof(recdb->f);
287 return ((size_t)recdb->pos >= recdb->length);
299 switch (recdb->type) {
301 res = fgetc(recdb->f);
305 res = dbeof(recdb) ? EOF : recdb->s[recdb->pos++];
311 if (res == EOL) recdb->ctx.line++, recdb->ctx.col=1;
312 else if (res != EOF) recdb->ctx.col++;
317 dbungetc(int c, RECDB *recdb)
319 switch (recdb->type) {
325 recdb->s[--recdb->pos] = c;
328 if (c == EOL) recdb->ctx.line--, recdb->ctx.col=-1;
329 else recdb->ctx.col--;
332 /* returns first non-whitespace, non-comment character (-1 for EOF found) */
334 parse_skip_ws(RECDB *recdb)
336 int c, d, in_comment = 0;
337 while (!dbeof(recdb)) {
339 if (c == EOF) return EOF;
340 if (isspace(c)) continue;
341 if (c != '/') return c;
342 if ((d = dbgetc(recdb)) == '*') {
343 /* C style comment, with slash star comment star slash */
348 } while (c != '*' && c != EOF);
349 if ((c = dbgetc(recdb)) == '/') in_comment = 0;
350 } while (in_comment);
351 } else if (d == '/') {
352 /* C++ style comment, with slash slash comment newline */
355 } while (c != EOF && c != EOL);
357 if (d != EOF) dbungetc(d, recdb);
365 parse_qstring(RECDB *recdb)
368 int used=0, size=8, c;
369 struct recdb_context start_ctx;
372 if ((c = parse_skip_ws(recdb)) == EOF) return NULL;
373 start_ctx = recdb->ctx;
374 if (c != '"') ABORT(recdb, EXPECTED_OPEN_QUOTE, c);
376 while (!dbeof(recdb) && (c = dbgetc(recdb)) != '"') {
378 /* There should never be a literal newline, as it is saved as a \n */
381 ABORT(recdb, UNTERMINATED_STRING, ' ');
385 switch (c = dbgetc(recdb)) {
386 case '0': /* \<octal>, 000 through 377 */
395 char digits[3] = { (char)c, '\0', '\0' };
396 for (i=1; i < 3; i++) {
397 /* Maximum of \377, so there's a max of 2 digits
398 * if digits[0] > '3' (no \400, but \40 is fine) */
399 if (i == 2 && digits[0] > '3') {
402 if ((c = dbgetc(recdb)) == EOF) {
405 if ((c < '0') || (c > '7')) {
412 c = (int)strtol(digits, NULL, 8);
421 char digits[3] = { '\0', '\0', '\0' };
422 for (i=0; i < 2; i++) {
423 if ((c = dbgetc(recdb)) == EOF) {
433 c = (int)strtol(digits, NULL, 16);
441 case 'a': buff[used++] = '\a'; break;
442 case 'b': buff[used++] = '\b'; break;
443 case 't': buff[used++] = '\t'; break;
444 case 'n': buff[used++] = EOL; break;
445 case 'v': buff[used++] = '\v'; break;
446 case 'f': buff[used++] = '\f'; break;
447 case 'r': buff[used++] = '\r'; break;
448 case '\\': buff[used++] = '\\'; break;
449 case '"': buff[used++] = '"'; break;
450 default: buff[used++] = '\\'; buff[used++] = c; break;
455 buff = realloc(buff, size);
458 if (c != '"' && dbeof(recdb)) {
460 recdb->ctx = start_ctx;
461 ABORT(recdb, UNTERMINATED_STRING, EOF);
468 parse_object(RECDB *recdb)
472 struct record_data *rd;
474 if ((c = parse_skip_ws(recdb)) == EOF) return NULL;
475 if (c != '{') ABORT(recdb, EXPECTED_OPEN_BRACE, c);
476 obj = alloc_object();
477 dict_set_free_keys(obj, free);
478 while (!dbeof(recdb)) {
479 if ((c = parse_skip_ws(recdb)) == '}') break;
482 parse_record_int(recdb, &name, &rd);
483 dict_insert(obj, name, rd);
489 parse_string_list(RECDB *recdb)
491 struct string_list *slist;
493 if ((c = parse_skip_ws(recdb)) == EOF) return NULL;
494 if (c != '(') ABORT(recdb, EXPECTED_OPEN_PAREN, c);
495 slist = alloc_string_list(4);
497 c = parse_skip_ws(recdb);
498 if (c == EOF || c == ')') break;
500 string_list_append(slist, parse_qstring(recdb));
501 c = parse_skip_ws(recdb);
502 if (c == EOF || c == ')') break;
503 if (c != ',') ABORT(recdb, EXPECTED_COMMA, c);
509 parse_record_int(RECDB *recdb, char **pname, struct record_data **prd)
512 *pname = parse_qstring(recdb);
513 c = parse_skip_ws(recdb);
517 ABORT(recdb, EXPECTED_RECORD_DATA, EOF);
519 if (c == '=') c = parse_skip_ws(recdb);
521 *prd = malloc(sizeof(**prd));
524 /* Don't use SET_RECORD_QSTRING, since that does an extra strdup() of the string. */
525 (*prd)->type = RECDB_QSTRING;
526 (*prd)->d.qstring = parse_qstring(recdb);
528 case '{': SET_RECORD_OBJECT(*prd, parse_object(recdb)); break;
529 case '(': SET_RECORD_STRING_LIST(*prd, parse_string_list(recdb)); break;
530 default: ABORT(recdb, EXPECTED_START_RECORD_DATA, c);
532 if ((c = parse_skip_ws(recdb)) != ';') ABORT(recdb, EXPECTED_SEMICOLON, c);
536 parse_database_int(RECDB *recdb)
539 struct record_data *rd;
540 dict_t db = alloc_database();
541 dict_set_free_keys(db, free);
542 while (!dbeof(recdb)) {
543 parse_record_int(recdb, &name, &rd);
544 if (name) dict_insert(db, name, rd);
550 failure_reason(int code)
554 case UNTERMINATED_STRING: reason = "Unterminated string"; break;
555 case EXPECTED_OPEN_QUOTE: reason = "Expected '\"'"; break;
556 case EXPECTED_OPEN_BRACE: reason = "Expected '{'"; break;
557 case EXPECTED_OPEN_PAREN: reason = "Expected '('"; break;
558 case EXPECTED_COMMA: reason = "Expected ','"; break;
559 case EXPECTED_START_RECORD_DATA: reason = "Expected start of some record data"; break;
560 case EXPECTED_SEMICOLON: reason = "Expected ';'"; break;
561 case EXPECTED_RECORD_DATA: reason = "Expected record data"; break;
562 default: reason = "Unknown error";
564 if (code == -1) reason = "Premature end of file";
569 explain_failure(RECDB *recdb, int code)
571 log_module(MAIN_LOG, LOG_ERROR, "%s (got '%c') at %s line %d column %d.",
572 failure_reason(code), code & 255,
573 recdb->source, recdb->ctx.line, recdb->ctx.col);
577 parse_record(const char *text, char **pname, struct record_data **prd)
583 recdb.source = "<user-supplied text>";
585 recdb.s = strdup(text);
586 recdb.length = strlen(text);
588 recdb.type = RECDB_STRING;
589 recdb.ctx.line = recdb.ctx.col = 1;
590 if ((res = setjmp(recdb.env)) == 0) {
591 parse_record_int(&recdb, pname, prd);
596 return failure_reason(res);
601 parse_database(const char *filename)
606 struct stat statinfo;
608 recdb.source = filename;
609 if (!(recdb.f = fopen(filename, "r"))) {
610 log_module(MAIN_LOG, LOG_ERROR, "Unable to open database file '%s' for reading: %s", filename, strerror(errno));
614 if (fstat(fileno(recdb.f), &statinfo)) {
615 log_module(MAIN_LOG, LOG_ERROR, "Unable to fstat database file '%s': %s", filename, strerror(errno));
619 recdb.length = (size_t)statinfo.st_size;
620 if (recdb.length == 0) {
622 return alloc_database();
627 if (!mmap_error && (recdb.s = mmap(NULL, recdb.length, PROT_READ|PROT_WRITE, MAP_PRIVATE, fileno(recdb.f), 0)) != MAP_FAILED) {
628 recdb.type = RECDB_MMAP;
629 madvise(recdb.s, recdb.length, MADV_SEQUENTIAL);
631 /* Fall back to stdio */
633 log_module(MAIN_LOG, LOG_WARNING, "Unable to mmap database file '%s' (falling back to stdio): %s", filename, strerror(errno));
640 recdb.type = RECDB_FILE;
643 recdb.ctx.line = recdb.ctx.col = 1;
646 if ((res = setjmp(recdb.env)) == 0) {
647 db = parse_database_int(&recdb);
649 explain_failure(&recdb, res);
653 switch (recdb.type) {
656 munmap(recdb.s, recdb.length);