Add a counter to the 'database deltree' CLI command.
[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\n");
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 int database_put(int fd, int argc, char *argv[])
244 {
245         int res;
246         if (argc != 5)
247                 return RESULT_SHOWUSAGE;
248         res = ast_db_put(argv[2], argv[3], argv[4]);
249         if (res)  {
250                 ast_cli(fd, "Failed to update entry\n");
251         } else {
252                 ast_cli(fd, "Updated database successfully\n");
253         }
254         return RESULT_SUCCESS;
255 }
256
257 static int database_get(int fd, int argc, char *argv[])
258 {
259         int res;
260         char tmp[256];
261         if (argc != 4)
262                 return RESULT_SHOWUSAGE;
263         res = ast_db_get(argv[2], argv[3], tmp, sizeof(tmp));
264         if (res) {
265                 ast_cli(fd, "Database entry not found.\n");
266         } else {
267                 ast_cli(fd, "Value: %s\n", tmp);
268         }
269         return RESULT_SUCCESS;
270 }
271
272 static int database_del(int fd, int argc, char *argv[])
273 {
274         int res;
275         if (argc != 4)
276                 return RESULT_SHOWUSAGE;
277         res = ast_db_del(argv[2], argv[3]);
278         if (res) {
279                 ast_cli(fd, "Database entry does not exist.\n");
280         } else {
281                 ast_cli(fd, "Database entry removed.\n");
282         }
283         return RESULT_SUCCESS;
284 }
285
286 static int database_deltree(int fd, int argc, char *argv[])
287 {
288         int res;
289         if ((argc < 3) || (argc > 4))
290                 return RESULT_SHOWUSAGE;
291         if (argc == 4) {
292                 res = ast_db_deltree(argv[2], argv[3]);
293         } else {
294                 res = ast_db_deltree(argv[2], NULL);
295         }
296         if (res < 0) {
297                 ast_cli(fd, "Database entries do not exist.\n");
298         } else {
299                 ast_cli(fd, "%d database entries removed.\n",res);
300         }
301         return RESULT_SUCCESS;
302 }
303
304 static int database_show(int fd, int argc, char *argv[])
305 {
306         char prefix[256];
307         DBT key, data;
308         char *keys, *values;
309         int res;
310         int pass;
311         int counter = 0;
312
313         if (argc == 4) {
314                 /* Family and key tree */
315                 snprintf(prefix, sizeof(prefix), "/%s/%s", argv[2], argv[3]);
316         } else if (argc == 3) {
317                 /* Family only */
318                 snprintf(prefix, sizeof(prefix), "/%s", argv[2]);
319         } else if (argc == 2) {
320                 /* Neither */
321                 prefix[0] = '\0';
322         } else {
323                 return RESULT_SHOWUSAGE;
324         }
325         ast_mutex_lock(&dblock);
326         if (dbinit()) {
327                 ast_mutex_unlock(&dblock);
328                 ast_cli(fd, "Database unavailable\n");
329                 return RESULT_SUCCESS;  
330         }
331         memset(&key, 0, sizeof(key));
332         memset(&data, 0, sizeof(data));
333         pass = 0;
334         while (!(res = astdb->seq(astdb, &key, &data, pass++ ? R_NEXT : R_FIRST))) {
335                 if (key.size) {
336                         keys = key.data;
337                         keys[key.size - 1] = '\0';
338                 } else {
339                         keys = "<bad key>";
340                 }
341                 if (data.size) {
342                         values = data.data;
343                         values[data.size - 1]='\0';
344                 } else {
345                         values = "<bad value>";
346                 }
347                 if (keymatch(keys, prefix)) {
348                         ast_cli(fd, "%-50s: %-25s\n", keys, values);
349                         counter++;
350                 }
351         }
352         ast_mutex_unlock(&dblock);
353         ast_cli(fd, "%d results found.\n", counter);
354         return RESULT_SUCCESS;  
355 }
356
357 static int database_showkey(int fd, int argc, char *argv[])
358 {
359         char suffix[256];
360         DBT key, data;
361         char *keys, *values;
362         int res;
363         int pass;
364         int counter = 0;
365
366         if (argc == 3) {
367                 /* Key only */
368                 snprintf(suffix, sizeof(suffix), "/%s", argv[2]);
369         } else {
370                 return RESULT_SHOWUSAGE;
371         }
372         ast_mutex_lock(&dblock);
373         if (dbinit()) {
374                 ast_mutex_unlock(&dblock);
375                 ast_cli(fd, "Database unavailable\n");
376                 return RESULT_SUCCESS;  
377         }
378         memset(&key, 0, sizeof(key));
379         memset(&data, 0, sizeof(data));
380         pass = 0;
381         while (!(res = astdb->seq(astdb, &key, &data, pass++ ? R_NEXT : R_FIRST))) {
382                 if (key.size) {
383                         keys = key.data;
384                         keys[key.size - 1] = '\0';
385                 } else {
386                         keys = "<bad key>";
387                 }
388                 if (data.size) {
389                         values = data.data;
390                         values[data.size - 1]='\0';
391                 } else {
392                         values = "<bad value>";
393                 }
394                 if (subkeymatch(keys, suffix)) {
395                         ast_cli(fd, "%-50s: %-25s\n", keys, values);
396                         counter++;
397                 }
398         }
399         ast_mutex_unlock(&dblock);
400         ast_cli(fd, "%d results found.\n", counter);
401         return RESULT_SUCCESS;  
402 }
403
404 struct ast_db_entry *ast_db_gettree(const char *family, const char *keytree)
405 {
406         char prefix[256];
407         DBT key, data;
408         char *keys, *values;
409         int values_len;
410         int res;
411         int pass;
412         struct ast_db_entry *last = NULL;
413         struct ast_db_entry *cur, *ret=NULL;
414
415         if (!ast_strlen_zero(family)) {
416                 if (!ast_strlen_zero(keytree)) {
417                         /* Family and key tree */
418                         snprintf(prefix, sizeof(prefix), "/%s/%s", family, prefix);
419                 } else {
420                         /* Family only */
421                         snprintf(prefix, sizeof(prefix), "/%s", family);
422                 }
423         } else {
424                 prefix[0] = '\0';
425         }
426         ast_mutex_lock(&dblock);
427         if (dbinit()) {
428                 ast_mutex_unlock(&dblock);
429                 ast_log(LOG_WARNING, "Database unavailable\n");
430                 return NULL;    
431         }
432         memset(&key, 0, sizeof(key));
433         memset(&data, 0, sizeof(data));
434         pass = 0;
435         while (!(res = astdb->seq(astdb, &key, &data, pass++ ? R_NEXT : R_FIRST))) {
436                 if (key.size) {
437                         keys = key.data;
438                         keys[key.size - 1] = '\0';
439                 } else {
440                         keys = "<bad key>";
441                 }
442                 if (data.size) {
443                         values = data.data;
444                         values[data.size - 1] = '\0';
445                 } else {
446                         values = "<bad value>";
447                 }
448                 values_len = strlen(values) + 1;
449                 if (keymatch(keys, prefix) && (cur = ast_malloc(sizeof(*cur) + strlen(keys) + 1 + values_len))) {
450                         cur->next = NULL;
451                         cur->key = cur->data + values_len;
452                         strcpy(cur->data, values);
453                         strcpy(cur->key, keys);
454                         if (last) {
455                                 last->next = cur;
456                         } else {
457                                 ret = cur;
458                         }
459                         last = cur;
460                 }
461         }
462         ast_mutex_unlock(&dblock);
463         return ret;     
464 }
465
466 void ast_db_freetree(struct ast_db_entry *dbe)
467 {
468         struct ast_db_entry *last;
469         while (dbe) {
470                 last = dbe;
471                 dbe = dbe->next;
472                 ast_free(last);
473         }
474 }
475
476 static const char database_show_usage[] =
477 "Usage: database show [family [keytree]]\n"
478 "       Shows Asterisk database contents, optionally restricted\n"
479 "to a given family, or family and keytree.\n";
480
481 static const char database_showkey_usage[] =
482 "Usage: database showkey <keytree>\n"
483 "       Shows Asterisk database contents, restricted to a given key.\n";
484
485 static const char database_put_usage[] =
486 "Usage: database put <family> <key> <value>\n"
487 "       Adds or updates an entry in the Asterisk database for\n"
488 "a given family, key, and value.\n";
489
490 static const char database_get_usage[] =
491 "Usage: database get <family> <key>\n"
492 "       Retrieves an entry in the Asterisk database for a given\n"
493 "family and key.\n";
494
495 static const char database_del_usage[] =
496 "Usage: database del <family> <key>\n"
497 "       Deletes an entry in the Asterisk database for a given\n"
498 "family and key.\n";
499
500 static const char database_deltree_usage[] =
501 "Usage: database deltree <family> [keytree]\n"
502 "       Deletes a family or specific keytree within a family\n"
503 "in the Asterisk database.\n";
504
505 struct ast_cli_entry cli_database[] = {
506         { { "database", "show", NULL },
507         database_show, "Shows database contents",
508         database_show_usage },
509
510         { { "database", "showkey", NULL },
511         database_showkey, "Shows database contents",
512         database_showkey_usage },
513
514         { { "database", "get", NULL },
515         database_get, "Gets database value",
516         database_get_usage },
517
518         { { "database", "put", NULL },
519         database_put, "Adds/updates database value",
520         database_put_usage },
521
522         { { "database", "del", NULL },
523         database_del, "Removes database key/value",
524         database_del_usage },
525
526         { { "database", "deltree", NULL },
527         database_deltree, "Removes database keytree/values",
528         database_deltree_usage },
529 };
530
531 static int manager_dbput(struct mansession *s, const struct message *m)
532 {
533         const char *family = astman_get_header(m, "Family");
534         const char *key = astman_get_header(m, "Key");
535         const char *val = astman_get_header(m, "Val");
536         int res;
537
538         if (ast_strlen_zero(family)) {
539                 astman_send_error(s, m, "No family specified");
540                 return 0;
541         }
542         if (ast_strlen_zero(key)) {
543                 astman_send_error(s, m, "No key specified");
544                 return 0;
545         }
546
547         res = ast_db_put(family, key, S_OR(val, ""));
548         if (res) {
549                 astman_send_error(s, m, "Failed to update entry");
550         } else {
551                 astman_send_ack(s, m, "Updated database successfully");
552         }
553         return 0;
554 }
555
556 static int manager_dbget(struct mansession *s, const struct message *m)
557 {
558         const char *id = astman_get_header(m,"ActionID");
559         char idText[256] = "";
560         const char *family = astman_get_header(m, "Family");
561         const char *key = astman_get_header(m, "Key");
562         char tmp[256];
563         int res;
564
565         if (ast_strlen_zero(family)) {
566                 astman_send_error(s, m, "No family specified.");
567                 return 0;
568         }
569         if (ast_strlen_zero(key)) {
570                 astman_send_error(s, m, "No key specified.");
571                 return 0;
572         }
573
574         if (!ast_strlen_zero(id))
575                 snprintf(idText, sizeof(idText) ,"ActionID: %s\r\n", id);
576
577         res = ast_db_get(family, key, tmp, sizeof(tmp));
578         if (res) {
579                 astman_send_error(s, m, "Database entry not found");
580         } else {
581                 astman_send_ack(s, m, "Result will follow");
582                 astman_append(s, "Event: DBGetResponse\r\n"
583                                 "Family: %s\r\n"
584                                 "Key: %s\r\n"
585                                 "Val: %s\r\n"
586                                 "%s"
587                                 "\r\n",
588                                 family, key, tmp, idText);
589         }
590         return 0;
591 }
592
593 static int manager_dbdel(struct mansession *s, const struct message *m)
594 {
595         const char *family = astman_get_header(m, "Family");
596         const char *key = astman_get_header(m, "Key");
597         int res;
598
599         if (ast_strlen_zero(family)) {
600                 astman_send_error(s, m, "No family specified.");
601                 return 0;
602         }
603
604         if (ast_strlen_zero(key)) {
605                 astman_send_error(s, m, "No key specified.");
606                 return 0;
607         }
608
609         res = ast_db_del(family, key);
610         if (res)
611                 astman_send_error(s, m, "Database entry not found");
612         else
613                 astman_send_ack(s, m, "Key deleted successfully");
614
615         return 0;
616 }
617
618 static int manager_dbdeltree(struct mansession *s, const struct message *m)
619 {
620         const char *family = astman_get_header(m, "Family");
621         const char *key = astman_get_header(m, "Key");
622         int res;
623
624         if (ast_strlen_zero(family)) {
625                 astman_send_error(s, m, "No family specified.");
626                 return 0;
627         }
628
629         if (!ast_strlen_zero(key))
630                 res = ast_db_deltree(family, key);
631         else
632                 res = ast_db_deltree(family, NULL);
633
634         if (res < 0)
635                 astman_send_error(s, m, "Database entry not found");
636         else
637                 astman_send_ack(s, m, "Key tree deleted successfully");
638         
639         return 0;
640 }
641
642 int astdb_init(void)
643 {
644         dbinit();
645         ast_cli_register_multiple(cli_database, sizeof(cli_database) / sizeof(struct ast_cli_entry));
646         ast_manager_register("DBGet", EVENT_FLAG_SYSTEM, manager_dbget, "Get DB Entry");
647         ast_manager_register("DBPut", EVENT_FLAG_SYSTEM, manager_dbput, "Put DB Entry");
648         ast_manager_register("DBDel", EVENT_FLAG_SYSTEM, manager_dbdel, "Delete DB Entry");
649         ast_manager_register("DBDelTree", EVENT_FLAG_SYSTEM, manager_dbdeltree, "Delete DB Tree");
650         return 0;
651 }