Use the same delimited character as the FILTER function in FIELDQTY and CUT.
[asterisk/asterisk.git] / main / db.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2005, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  *
21  * \brief ASTdb Management
22  *
23  * \author Mark Spencer <markster@digium.com> 
24  *
25  * \note DB3 is licensed under Sleepycat Public License and is thus incompatible
26  * with GPL.  To avoid having to make another exception (and complicate 
27  * licensing even further) we elect to use DB1 which is BSD licensed 
28  */
29
30 #include "asterisk.h"
31
32 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
33
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <string.h>
37 #include <sys/time.h>
38 #include <signal.h>
39 #include <errno.h>
40 #include <unistd.h>
41 #include <dirent.h>
42
43 #include "asterisk/channel.h"
44 #include "asterisk/file.h"
45 #include "asterisk/app.h"
46 #include "asterisk/dsp.h"
47 #include "asterisk/logger.h"
48 #include "asterisk/options.h"
49 #include "asterisk/astdb.h"
50 #include "asterisk/cli.h"
51 #include "asterisk/utils.h"
52 #include "asterisk/lock.h"
53 #include "asterisk/manager.h"
54 #include "db1-ast/include/db.h"
55
56 #ifdef __CYGWIN__
57 #define dbopen __dbopen
58 #endif
59
60 static DB *astdb;
61 AST_MUTEX_DEFINE_STATIC(dblock);
62
63 static int dbinit(void) 
64 {
65         if (!astdb && !(astdb = dbopen((char *)ast_config_AST_DB, O_CREAT | O_RDWR, AST_FILE_MODE, DB_BTREE, NULL))) {
66                 ast_log(LOG_WARNING, "Unable to open Asterisk database '%s': %s\n", ast_config_AST_DB, strerror(errno));
67                 return -1;
68         }
69         return 0;
70 }
71
72
73 static inline int keymatch(const char *key, const char *prefix)
74 {
75         int preflen = strlen(prefix);
76         if (!preflen)
77                 return 1;
78         if (!strcasecmp(key, prefix))
79                 return 1;
80         if ((strlen(key) > preflen) && !strncasecmp(key, prefix, preflen)) {
81                 if (key[preflen] == '/')
82                         return 1;
83         }
84         return 0;
85 }
86
87 static inline int subkeymatch(const char *key, const char *suffix)
88 {
89         int suffixlen = strlen(suffix);
90         if (suffixlen) {
91                 const char *subkey = key + strlen(key) - suffixlen;
92                 if (subkey < key)
93                         return 0;
94                 if (!strcasecmp(subkey, suffix))
95                         return 1;
96         }
97         return 0;
98 }
99
100 int ast_db_deltree(const char *family, const char *keytree)
101 {
102         char prefix[256];
103         DBT key, data;
104         char *keys;
105         int res;
106         int pass;
107         int counter = 0;
108         
109         if (family) {
110                 if (keytree) {
111                         snprintf(prefix, sizeof(prefix), "/%s/%s", family, keytree);
112                 } else {
113                         snprintf(prefix, sizeof(prefix), "/%s", family);
114                 }
115         } else if (keytree) {
116                 return -1;
117         } else {
118                 prefix[0] = '\0';
119         }
120         
121         ast_mutex_lock(&dblock);
122         if (dbinit()) {
123                 ast_mutex_unlock(&dblock);
124                 return -1;
125         }
126         
127         memset(&key, 0, sizeof(key));
128         memset(&data, 0, sizeof(data));
129         pass = 0;
130         while (!(res = astdb->seq(astdb, &key, &data, pass++ ? R_NEXT : R_FIRST))) {
131                 if (key.size) {
132                         keys = key.data;
133                         keys[key.size - 1] = '\0';
134                 } else {
135                         keys = "<bad key>";
136                 }
137                 if (keymatch(keys, prefix)) {
138                         astdb->del(astdb, &key, 0);
139                         counter++;
140                 }
141         }
142         astdb->sync(astdb, 0);
143         ast_mutex_unlock(&dblock);
144         return counter;
145 }
146
147 int ast_db_put(const char *family, const char *keys, const char *value)
148 {
149         char fullkey[256];
150         DBT key, data;
151         int res, fullkeylen;
152
153         ast_mutex_lock(&dblock);
154         if (dbinit()) {
155                 ast_mutex_unlock(&dblock);
156                 return -1;
157         }
158
159         fullkeylen = snprintf(fullkey, sizeof(fullkey), "/%s/%s", family, keys);
160         memset(&key, 0, sizeof(key));
161         memset(&data, 0, sizeof(data));
162         key.data = fullkey;
163         key.size = fullkeylen + 1;
164         data.data = (char *) value;
165         data.size = strlen(value) + 1;
166         res = astdb->put(astdb, &key, &data, 0);
167         astdb->sync(astdb, 0);
168         ast_mutex_unlock(&dblock);
169         if (res)
170                 ast_log(LOG_WARNING, "Unable to put value '%s' for key '%s' in family '%s'\n", value, keys, family);
171         return res;
172 }
173
174 int ast_db_get(const char *family, const char *keys, char *value, int valuelen)
175 {
176         char fullkey[256] = "";
177         DBT key, data;
178         int res, fullkeylen;
179
180         ast_mutex_lock(&dblock);
181         if (dbinit()) {
182                 ast_mutex_unlock(&dblock);
183                 return -1;
184         }
185
186         fullkeylen = snprintf(fullkey, sizeof(fullkey), "/%s/%s", family, keys);
187         memset(&key, 0, sizeof(key));
188         memset(&data, 0, sizeof(data));
189         memset(value, 0, valuelen);
190         key.data = fullkey;
191         key.size = fullkeylen + 1;
192         
193         res = astdb->get(astdb, &key, &data, 0);
194         
195         ast_mutex_unlock(&dblock);
196
197         /* Be sure to NULL terminate our data either way */
198         if (res) {
199                 ast_debug(1, "Unable to find key '%s' in family '%s'\n", keys, family);
200         } else {
201 #if 0
202                 printf("Got value of size %d\n", data.size);
203 #endif
204                 if (data.size) {
205                         ((char *)data.data)[data.size - 1] = '\0';
206                         /* Make sure that we don't write too much to the dst pointer or we don't read too much from the source pointer */
207                         ast_copy_string(value, data.data, (valuelen > data.size) ? data.size : valuelen);
208                 } else {
209                         ast_log(LOG_NOTICE, "Strange, empty value for /%s/%s\n", family, keys);
210                 }
211         }
212         return res;
213 }
214
215 int ast_db_del(const char *family, const char *keys)
216 {
217         char fullkey[256];
218         DBT key;
219         int res, fullkeylen;
220
221         ast_mutex_lock(&dblock);
222         if (dbinit()) {
223                 ast_mutex_unlock(&dblock);
224                 return -1;
225         }
226         
227         fullkeylen = snprintf(fullkey, sizeof(fullkey), "/%s/%s", family, keys);
228         memset(&key, 0, sizeof(key));
229         key.data = fullkey;
230         key.size = fullkeylen + 1;
231         
232         res = astdb->del(astdb, &key, 0);
233         astdb->sync(astdb, 0);
234         
235         ast_mutex_unlock(&dblock);
236
237         if (res) {
238                 ast_debug(1, "Unable to find key '%s' in family '%s'\n", keys, family);
239         }
240         return res;
241 }
242
243 static char *handle_cli_database_put(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
244 {
245         int res;
246
247         switch (cmd) {
248         case CLI_INIT:
249                 e->command = "database put";
250                 e->usage =
251                         "Usage: database put <family> <key> <value>\n"
252                         "       Adds or updates an entry in the Asterisk database for\n"
253                         "       a given family, key, and value.\n";
254                 return NULL;
255         case CLI_GENERATE:
256                 return NULL;
257         }
258
259         if (a->argc != 5)
260                 return CLI_SHOWUSAGE;
261         res = ast_db_put(a->argv[2], a->argv[3], a->argv[4]);
262         if (res)  {
263                 ast_cli(a->fd, "Failed to update entry\n");
264         } else {
265                 ast_cli(a->fd, "Updated database successfully\n");
266         }
267         return CLI_SUCCESS;
268 }
269
270 static char *handle_cli_database_get(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
271 {
272         int res;
273         char tmp[256];
274
275         switch (cmd) {
276         case CLI_INIT:
277                 e->command = "database get";
278                 e->usage =
279                         "Usage: database get <family> <key>\n"
280                         "       Retrieves an entry in the Asterisk database for a given\n"
281                         "       family and key.\n";
282                 return NULL;
283         case CLI_GENERATE:
284                 return NULL;
285         }
286
287         if (a->argc != 4)
288                 return CLI_SHOWUSAGE;
289         res = ast_db_get(a->argv[2], a->argv[3], tmp, sizeof(tmp));
290         if (res) {
291                 ast_cli(a->fd, "Database entry not found.\n");
292         } else {
293                 ast_cli(a->fd, "Value: %s\n", tmp);
294         }
295         return CLI_SUCCESS;
296 }
297
298 static char *handle_cli_database_del(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
299 {
300         int res;
301
302         switch (cmd) {
303         case CLI_INIT:
304                 e->command = "database del";
305                 e->usage =
306                         "Usage: database del <family> <key>\n"
307                         "       Deletes an entry in the Asterisk database for a given\n"
308                         "       family and key.\n";
309                 return NULL;
310         case CLI_GENERATE:
311                 return NULL;
312         }
313
314         if (a->argc != 4)
315                 return CLI_SHOWUSAGE;
316         res = ast_db_del(a->argv[2], a->argv[3]);
317         if (res) {
318                 ast_cli(a->fd, "Database entry does not exist.\n");
319         } else {
320                 ast_cli(a->fd, "Database entry removed.\n");
321         }
322         return CLI_SUCCESS;
323 }
324
325 static char *handle_cli_database_deltree(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
326 {
327         int res;
328
329         switch (cmd) {
330         case CLI_INIT:
331                 e->command = "database deltree";
332                 e->usage =
333                         "Usage: database deltree <family> [keytree]\n"
334                         "       Deletes a family or specific keytree within a family\n"
335                         "       in the Asterisk database.\n";
336                 return NULL;
337         case CLI_GENERATE:
338                 return NULL;
339         }
340
341         if ((a->argc < 3) || (a->argc > 4))
342                 return CLI_SHOWUSAGE;
343         if (a->argc == 4) {
344                 res = ast_db_deltree(a->argv[2], a->argv[3]);
345         } else {
346                 res = ast_db_deltree(a->argv[2], NULL);
347         }
348         if (res < 0) {
349                 ast_cli(a->fd, "Database entries do not exist.\n");
350         } else {
351                 ast_cli(a->fd, "%d database entries removed.\n",res);
352         }
353         return CLI_SUCCESS;
354 }
355
356 static char *handle_cli_database_show(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
357 {
358         char prefix[256];
359         DBT key, data;
360         char *keys, *values;
361         int res;
362         int pass;
363         int counter = 0;
364
365         switch (cmd) {
366         case CLI_INIT:
367                 e->command = "database show";
368                 e->usage =
369                         "Usage: database show [family [keytree]]\n"
370                         "       Shows Asterisk database contents, optionally restricted\n"
371                         "       to a given family, or family and keytree.\n";
372                 return NULL;
373         case CLI_GENERATE:
374                 return NULL;
375         }
376
377         if (a->argc == 4) {
378                 /* Family and key tree */
379                 snprintf(prefix, sizeof(prefix), "/%s/%s", a->argv[2], a->argv[3]);
380         } else if (a->argc == 3) {
381                 /* Family only */
382                 snprintf(prefix, sizeof(prefix), "/%s", a->argv[2]);
383         } else if (a->argc == 2) {
384                 /* Neither */
385                 prefix[0] = '\0';
386         } else {
387                 return CLI_SHOWUSAGE;
388         }
389         ast_mutex_lock(&dblock);
390         if (dbinit()) {
391                 ast_mutex_unlock(&dblock);
392                 ast_cli(a->fd, "Database unavailable\n");
393                 return CLI_SUCCESS;     
394         }
395         memset(&key, 0, sizeof(key));
396         memset(&data, 0, sizeof(data));
397         pass = 0;
398         while (!(res = astdb->seq(astdb, &key, &data, pass++ ? R_NEXT : R_FIRST))) {
399                 if (key.size) {
400                         keys = key.data;
401                         keys[key.size - 1] = '\0';
402                 } else {
403                         keys = "<bad key>";
404                 }
405                 if (data.size) {
406                         values = data.data;
407                         values[data.size - 1]='\0';
408                 } else {
409                         values = "<bad value>";
410                 }
411                 if (keymatch(keys, prefix)) {
412                         ast_cli(a->fd, "%-50s: %-25s\n", keys, values);
413                         counter++;
414                 }
415         }
416         ast_mutex_unlock(&dblock);
417         ast_cli(a->fd, "%d results found.\n", counter);
418         return CLI_SUCCESS;     
419 }
420
421 static char *handle_cli_database_showkey(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
422 {
423         char suffix[256];
424         DBT key, data;
425         char *keys, *values;
426         int res;
427         int pass;
428         int counter = 0;
429
430         switch (cmd) {
431         case CLI_INIT:
432                 e->command = "database show";
433                 e->usage =
434                         "Usage: database showkey <keytree>\n"
435                         "       Shows Asterisk database contents, restricted to a given key.\n";
436                 return NULL;
437         case CLI_GENERATE:
438                 return NULL;
439         }
440
441         if (a->argc == 3) {
442                 /* Key only */
443                 snprintf(suffix, sizeof(suffix), "/%s", a->argv[2]);
444         } else {
445                 return CLI_SHOWUSAGE;
446         }
447         ast_mutex_lock(&dblock);
448         if (dbinit()) {
449                 ast_mutex_unlock(&dblock);
450                 ast_cli(a->fd, "Database unavailable\n");
451                 return CLI_SUCCESS;     
452         }
453         memset(&key, 0, sizeof(key));
454         memset(&data, 0, sizeof(data));
455         pass = 0;
456         while (!(res = astdb->seq(astdb, &key, &data, pass++ ? R_NEXT : R_FIRST))) {
457                 if (key.size) {
458                         keys = key.data;
459                         keys[key.size - 1] = '\0';
460                 } else {
461                         keys = "<bad key>";
462                 }
463                 if (data.size) {
464                         values = data.data;
465                         values[data.size - 1]='\0';
466                 } else {
467                         values = "<bad value>";
468                 }
469                 if (subkeymatch(keys, suffix)) {
470                         ast_cli(a->fd, "%-50s: %-25s\n", keys, values);
471                         counter++;
472                 }
473         }
474         ast_mutex_unlock(&dblock);
475         ast_cli(a->fd, "%d results found.\n", counter);
476         return CLI_SUCCESS;     
477 }
478
479 struct ast_db_entry *ast_db_gettree(const char *family, const char *keytree)
480 {
481         char prefix[256];
482         DBT key, data;
483         char *keys, *values;
484         int values_len;
485         int res;
486         int pass;
487         struct ast_db_entry *last = NULL;
488         struct ast_db_entry *cur, *ret=NULL;
489
490         if (!ast_strlen_zero(family)) {
491                 if (!ast_strlen_zero(keytree)) {
492                         /* Family and key tree */
493                         snprintf(prefix, sizeof(prefix), "/%s/%s", family, prefix);
494                 } else {
495                         /* Family only */
496                         snprintf(prefix, sizeof(prefix), "/%s", family);
497                 }
498         } else {
499                 prefix[0] = '\0';
500         }
501         ast_mutex_lock(&dblock);
502         if (dbinit()) {
503                 ast_mutex_unlock(&dblock);
504                 ast_log(LOG_WARNING, "Database unavailable\n");
505                 return NULL;    
506         }
507         memset(&key, 0, sizeof(key));
508         memset(&data, 0, sizeof(data));
509         pass = 0;
510         while (!(res = astdb->seq(astdb, &key, &data, pass++ ? R_NEXT : R_FIRST))) {
511                 if (key.size) {
512                         keys = key.data;
513                         keys[key.size - 1] = '\0';
514                 } else {
515                         keys = "<bad key>";
516                 }
517                 if (data.size) {
518                         values = data.data;
519                         values[data.size - 1] = '\0';
520                 } else {
521                         values = "<bad value>";
522                 }
523                 values_len = strlen(values) + 1;
524                 if (keymatch(keys, prefix) && (cur = ast_malloc(sizeof(*cur) + strlen(keys) + 1 + values_len))) {
525                         cur->next = NULL;
526                         cur->key = cur->data + values_len;
527                         strcpy(cur->data, values);
528                         strcpy(cur->key, keys);
529                         if (last) {
530                                 last->next = cur;
531                         } else {
532                                 ret = cur;
533                         }
534                         last = cur;
535                 }
536         }
537         ast_mutex_unlock(&dblock);
538         return ret;     
539 }
540
541 void ast_db_freetree(struct ast_db_entry *dbe)
542 {
543         struct ast_db_entry *last;
544         while (dbe) {
545                 last = dbe;
546                 dbe = dbe->next;
547                 ast_free(last);
548         }
549 }
550
551 struct ast_cli_entry cli_database[] = {
552         AST_CLI_DEFINE(handle_cli_database_show,    "Shows database contents"),
553         AST_CLI_DEFINE(handle_cli_database_showkey, "Shows database contents"),
554         AST_CLI_DEFINE(handle_cli_database_get,     "Gets database value"),
555         AST_CLI_DEFINE(handle_cli_database_put,     "Adds/updates database value"),
556         AST_CLI_DEFINE(handle_cli_database_del,     "Removes database key/value"),
557         AST_CLI_DEFINE(handle_cli_database_deltree, "Removes database keytree/values")
558 };
559
560 static int manager_dbput(struct mansession *s, const struct message *m)
561 {
562         const char *family = astman_get_header(m, "Family");
563         const char *key = astman_get_header(m, "Key");
564         const char *val = astman_get_header(m, "Val");
565         int res;
566
567         if (ast_strlen_zero(family)) {
568                 astman_send_error(s, m, "No family specified");
569                 return 0;
570         }
571         if (ast_strlen_zero(key)) {
572                 astman_send_error(s, m, "No key specified");
573                 return 0;
574         }
575
576         res = ast_db_put(family, key, S_OR(val, ""));
577         if (res) {
578                 astman_send_error(s, m, "Failed to update entry");
579         } else {
580                 astman_send_ack(s, m, "Updated database successfully");
581         }
582         return 0;
583 }
584
585 static int manager_dbget(struct mansession *s, const struct message *m)
586 {
587         const char *id = astman_get_header(m,"ActionID");
588         char idText[256] = "";
589         const char *family = astman_get_header(m, "Family");
590         const char *key = astman_get_header(m, "Key");
591         char tmp[256];
592         int res;
593
594         if (ast_strlen_zero(family)) {
595                 astman_send_error(s, m, "No family specified.");
596                 return 0;
597         }
598         if (ast_strlen_zero(key)) {
599                 astman_send_error(s, m, "No key specified.");
600                 return 0;
601         }
602
603         if (!ast_strlen_zero(id))
604                 snprintf(idText, sizeof(idText) ,"ActionID: %s\r\n", id);
605
606         res = ast_db_get(family, key, tmp, sizeof(tmp));
607         if (res) {
608                 astman_send_error(s, m, "Database entry not found");
609         } else {
610                 astman_send_ack(s, m, "Result will follow");
611                 astman_append(s, "Event: DBGetResponse\r\n"
612                                 "Family: %s\r\n"
613                                 "Key: %s\r\n"
614                                 "Val: %s\r\n"
615                                 "%s"
616                                 "\r\n",
617                                 family, key, tmp, idText);
618         }
619         return 0;
620 }
621
622 static int manager_dbdel(struct mansession *s, const struct message *m)
623 {
624         const char *family = astman_get_header(m, "Family");
625         const char *key = astman_get_header(m, "Key");
626         int res;
627
628         if (ast_strlen_zero(family)) {
629                 astman_send_error(s, m, "No family specified.");
630                 return 0;
631         }
632
633         if (ast_strlen_zero(key)) {
634                 astman_send_error(s, m, "No key specified.");
635                 return 0;
636         }
637
638         res = ast_db_del(family, key);
639         if (res)
640                 astman_send_error(s, m, "Database entry not found");
641         else
642                 astman_send_ack(s, m, "Key deleted successfully");
643
644         return 0;
645 }
646
647 static int manager_dbdeltree(struct mansession *s, const struct message *m)
648 {
649         const char *family = astman_get_header(m, "Family");
650         const char *key = astman_get_header(m, "Key");
651         int res;
652
653         if (ast_strlen_zero(family)) {
654                 astman_send_error(s, m, "No family specified.");
655                 return 0;
656         }
657
658         if (!ast_strlen_zero(key))
659                 res = ast_db_deltree(family, key);
660         else
661                 res = ast_db_deltree(family, NULL);
662
663         if (res < 0)
664                 astman_send_error(s, m, "Database entry not found");
665         else
666                 astman_send_ack(s, m, "Key tree deleted successfully");
667         
668         return 0;
669 }
670
671 int astdb_init(void)
672 {
673         dbinit();
674         ast_cli_register_multiple(cli_database, sizeof(cli_database) / sizeof(struct ast_cli_entry));
675         ast_manager_register("DBGet", EVENT_FLAG_SYSTEM, manager_dbget, "Get DB Entry");
676         ast_manager_register("DBPut", EVENT_FLAG_SYSTEM, manager_dbput, "Put DB Entry");
677         ast_manager_register("DBDel", EVENT_FLAG_SYSTEM, manager_dbdel, "Delete DB Entry");
678         ast_manager_register("DBDelTree", EVENT_FLAG_SYSTEM, manager_dbdeltree, "Delete DB Tree");
679         return 0;
680 }