Make the database show command spit out how many results it got. (issue #9332 reporte...
[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         
108         if (family) {
109                 if (keytree) {
110                         snprintf(prefix, sizeof(prefix), "/%s/%s", family, keytree);
111                 } else {
112                         snprintf(prefix, sizeof(prefix), "/%s", family);
113                 }
114         } else if (keytree) {
115                 return -1;
116         } else {
117                 prefix[0] = '\0';
118         }
119         
120         ast_mutex_lock(&dblock);
121         if (dbinit()) {
122                 ast_mutex_unlock(&dblock);
123                 return -1;
124         }
125         
126         memset(&key, 0, sizeof(key));
127         memset(&data, 0, sizeof(data));
128         pass = 0;
129         while (!(res = astdb->seq(astdb, &key, &data, pass++ ? R_NEXT : R_FIRST))) {
130                 if (key.size) {
131                         keys = key.data;
132                         keys[key.size - 1] = '\0';
133                 } else {
134                         keys = "<bad key>";
135                 }
136                 if (keymatch(keys, prefix)) {
137                         astdb->del(astdb, &key, 0);
138                 }
139         }
140         astdb->sync(astdb, 0);
141         ast_mutex_unlock(&dblock);
142         return 0;
143 }
144
145 int ast_db_put(const char *family, const char *keys, const char *value)
146 {
147         char fullkey[256];
148         DBT key, data;
149         int res, fullkeylen;
150
151         ast_mutex_lock(&dblock);
152         if (dbinit()) {
153                 ast_mutex_unlock(&dblock);
154                 return -1;
155         }
156
157         fullkeylen = snprintf(fullkey, sizeof(fullkey), "/%s/%s", family, keys);
158         memset(&key, 0, sizeof(key));
159         memset(&data, 0, sizeof(data));
160         key.data = fullkey;
161         key.size = fullkeylen + 1;
162         data.data = (char *) value;
163         data.size = strlen(value) + 1;
164         res = astdb->put(astdb, &key, &data, 0);
165         astdb->sync(astdb, 0);
166         ast_mutex_unlock(&dblock);
167         if (res)
168                 ast_log(LOG_WARNING, "Unable to put value '%s' for key '%s' in family '%s'\n", value, keys, family);
169         return res;
170 }
171
172 int ast_db_get(const char *family, const char *keys, char *value, int valuelen)
173 {
174         char fullkey[256] = "";
175         DBT key, data;
176         int res, fullkeylen;
177
178         ast_mutex_lock(&dblock);
179         if (dbinit()) {
180                 ast_mutex_unlock(&dblock);
181                 return -1;
182         }
183
184         fullkeylen = snprintf(fullkey, sizeof(fullkey), "/%s/%s", family, keys);
185         memset(&key, 0, sizeof(key));
186         memset(&data, 0, sizeof(data));
187         memset(value, 0, valuelen);
188         key.data = fullkey;
189         key.size = fullkeylen + 1;
190         
191         res = astdb->get(astdb, &key, &data, 0);
192         
193         ast_mutex_unlock(&dblock);
194
195         /* Be sure to NULL terminate our data either way */
196         if (res) {
197                 if (option_debug)
198                         ast_log(LOG_DEBUG, "Unable to find key '%s' in family '%s'\n", keys, family);
199         } else {
200 #if 0
201                 printf("Got value of size %d\n", data.size);
202 #endif
203                 if (data.size) {
204                         ((char *)data.data)[data.size - 1] = '\0';
205                         /* Make sure that we don't write too much to the dst pointer or we don't read too much from the source pointer */
206                         ast_copy_string(value, data.data, (valuelen > data.size) ? data.size : valuelen);
207                 } else {
208                         ast_log(LOG_NOTICE, "Strange, empty value for /%s/%s\n", family, keys);
209                 }
210         }
211         return res;
212 }
213
214 int ast_db_del(const char *family, const char *keys)
215 {
216         char fullkey[256];
217         DBT key;
218         int res, fullkeylen;
219
220         ast_mutex_lock(&dblock);
221         if (dbinit()) {
222                 ast_mutex_unlock(&dblock);
223                 return -1;
224         }
225         
226         fullkeylen = snprintf(fullkey, sizeof(fullkey), "/%s/%s", family, keys);
227         memset(&key, 0, sizeof(key));
228         key.data = fullkey;
229         key.size = fullkeylen + 1;
230         
231         res = astdb->del(astdb, &key, 0);
232         astdb->sync(astdb, 0);
233         
234         ast_mutex_unlock(&dblock);
235
236         if (res) {
237                 if (option_debug)
238                         ast_log(LOG_DEBUG, "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) {
297                 ast_cli(fd, "Database entries do not exist.\n");
298         } else {
299                 ast_cli(fd, "Database entries removed.\n");
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
312         if (argc == 4) {
313                 /* Family and key tree */
314                 snprintf(prefix, sizeof(prefix), "/%s/%s", argv[2], argv[3]);
315         } else if (argc == 3) {
316                 /* Family only */
317                 snprintf(prefix, sizeof(prefix), "/%s", argv[2]);
318         } else if (argc == 2) {
319                 /* Neither */
320                 prefix[0] = '\0';
321         } else {
322                 return RESULT_SHOWUSAGE;
323         }
324         ast_mutex_lock(&dblock);
325         if (dbinit()) {
326                 ast_mutex_unlock(&dblock);
327                 ast_cli(fd, "Database unavailable\n");
328                 return RESULT_SUCCESS;  
329         }
330         memset(&key, 0, sizeof(key));
331         memset(&data, 0, sizeof(data));
332         pass = 0;
333         while (!(res = astdb->seq(astdb, &key, &data, pass++ ? R_NEXT : R_FIRST))) {
334                 if (key.size) {
335                         keys = key.data;
336                         keys[key.size - 1] = '\0';
337                 } else {
338                         keys = "<bad key>";
339                 }
340                 if (data.size) {
341                         values = data.data;
342                         values[data.size - 1]='\0';
343                 } else {
344                         values = "<bad value>";
345                 }
346                 if (keymatch(keys, prefix)) {
347                                 ast_cli(fd, "%-50s: %-25s\n", keys, values);
348                 }
349         }
350         ast_mutex_unlock(&dblock);
351         return RESULT_SUCCESS;  
352 }
353
354 static int database_showkey(int fd, int argc, char *argv[])
355 {
356         char suffix[256];
357         DBT key, data;
358         char *keys, *values;
359         int res;
360         int pass;
361         int counter = 0;
362
363         if (argc == 3) {
364                 /* Key only */
365                 snprintf(suffix, sizeof(suffix), "/%s", argv[2]);
366         } else {
367                 return RESULT_SHOWUSAGE;
368         }
369         ast_mutex_lock(&dblock);
370         if (dbinit()) {
371                 ast_mutex_unlock(&dblock);
372                 ast_cli(fd, "Database unavailable\n");
373                 return RESULT_SUCCESS;  
374         }
375         memset(&key, 0, sizeof(key));
376         memset(&data, 0, sizeof(data));
377         pass = 0;
378         while (!(res = astdb->seq(astdb, &key, &data, pass++ ? R_NEXT : R_FIRST))) {
379                 if (key.size) {
380                         keys = key.data;
381                         keys[key.size - 1] = '\0';
382                 } else {
383                         keys = "<bad key>";
384                 }
385                 if (data.size) {
386                         values = data.data;
387                         values[data.size - 1]='\0';
388                 } else {
389                         values = "<bad value>";
390                 }
391                 if (subkeymatch(keys, suffix)) {
392                                 ast_cli(fd, "%-50s: %-25s\n", keys, values);
393                                 counter++;
394                 }
395         }
396         ast_mutex_unlock(&dblock);
397         ast_cli(fd, "%d results found.\n", counter);
398         return RESULT_SUCCESS;  
399 }
400
401 struct ast_db_entry *ast_db_gettree(const char *family, const char *keytree)
402 {
403         char prefix[256];
404         DBT key, data;
405         char *keys, *values;
406         int values_len;
407         int res;
408         int pass;
409         struct ast_db_entry *last = NULL;
410         struct ast_db_entry *cur, *ret=NULL;
411
412         if (!ast_strlen_zero(family)) {
413                 if (!ast_strlen_zero(keytree)) {
414                         /* Family and key tree */
415                         snprintf(prefix, sizeof(prefix), "/%s/%s", family, prefix);
416                 } else {
417                         /* Family only */
418                         snprintf(prefix, sizeof(prefix), "/%s", family);
419                 }
420         } else {
421                 prefix[0] = '\0';
422         }
423         ast_mutex_lock(&dblock);
424         if (dbinit()) {
425                 ast_mutex_unlock(&dblock);
426                 ast_log(LOG_WARNING, "Database unavailable\n");
427                 return NULL;    
428         }
429         memset(&key, 0, sizeof(key));
430         memset(&data, 0, sizeof(data));
431         pass = 0;
432         while (!(res = astdb->seq(astdb, &key, &data, pass++ ? R_NEXT : R_FIRST))) {
433                 if (key.size) {
434                         keys = key.data;
435                         keys[key.size - 1] = '\0';
436                 } else {
437                         keys = "<bad key>";
438                 }
439                 if (data.size) {
440                         values = data.data;
441                         values[data.size - 1] = '\0';
442                 } else {
443                         values = "<bad value>";
444                 }
445                 values_len = strlen(values) + 1;
446                 if (keymatch(keys, prefix) && (cur = ast_malloc(sizeof(*cur) + strlen(keys) + 1 + values_len))) {
447                         cur->next = NULL;
448                         cur->key = cur->data + values_len;
449                         strcpy(cur->data, values);
450                         strcpy(cur->key, keys);
451                         if (last) {
452                                 last->next = cur;
453                         } else {
454                                 ret = cur;
455                         }
456                         last = cur;
457                 }
458         }
459         ast_mutex_unlock(&dblock);
460         return ret;     
461 }
462
463 void ast_db_freetree(struct ast_db_entry *dbe)
464 {
465         struct ast_db_entry *last;
466         while (dbe) {
467                 last = dbe;
468                 dbe = dbe->next;
469                 free(last);
470         }
471 }
472
473 static const char database_show_usage[] =
474 "Usage: database show [family [keytree]]\n"
475 "       Shows Asterisk database contents, optionally restricted\n"
476 "to a given family, or family and keytree.\n";
477
478 static const char database_showkey_usage[] =
479 "Usage: database showkey <keytree>\n"
480 "       Shows Asterisk database contents, restricted to a given key.\n";
481
482 static const char database_put_usage[] =
483 "Usage: database put <family> <key> <value>\n"
484 "       Adds or updates an entry in the Asterisk database for\n"
485 "a given family, key, and value.\n";
486
487 static const char database_get_usage[] =
488 "Usage: database get <family> <key>\n"
489 "       Retrieves an entry in the Asterisk database for a given\n"
490 "family and key.\n";
491
492 static const char database_del_usage[] =
493 "Usage: database del <family> <key>\n"
494 "       Deletes an entry in the Asterisk database for a given\n"
495 "family and key.\n";
496
497 static const char database_deltree_usage[] =
498 "Usage: database deltree <family> [keytree]\n"
499 "       Deletes a family or specific keytree within a family\n"
500 "in the Asterisk database.\n";
501
502 struct ast_cli_entry cli_database[] = {
503         { { "database", "show", NULL },
504         database_show, "Shows database contents",
505         database_show_usage },
506
507         { { "database", "showkey", NULL },
508         database_showkey, "Shows database contents",
509         database_showkey_usage },
510
511         { { "database", "get", NULL },
512         database_get, "Gets database value",
513         database_get_usage },
514
515         { { "database", "put", NULL },
516         database_put, "Adds/updates database value",
517         database_put_usage },
518
519         { { "database", "del", NULL },
520         database_del, "Removes database key/value",
521         database_del_usage },
522
523         { { "database", "deltree", NULL },
524         database_deltree, "Removes database keytree/values",
525         database_deltree_usage },
526 };
527
528 static int manager_dbput(struct mansession *s, const struct message *m)
529 {
530         const char *family = astman_get_header(m, "Family");
531         const char *key = astman_get_header(m, "Key");
532         const char *val = astman_get_header(m, "Val");
533         int res;
534
535         if (ast_strlen_zero(family)) {
536                 astman_send_error(s, m, "No family specified");
537                 return 0;
538         }
539         if (ast_strlen_zero(key)) {
540                 astman_send_error(s, m, "No key specified");
541                 return 0;
542         }
543         if (ast_strlen_zero(val)) {
544                 astman_send_error(s, m, "No val specified");
545                 return 0;
546         }
547
548         res = ast_db_put(family, key, val);
549         if (res) {
550                 astman_send_error(s, m, "Failed to update entry");
551         } else {
552                 astman_send_ack(s, m, "Updated database successfully");
553         }
554         return 0;
555 }
556
557 static int manager_dbget(struct mansession *s, const struct message *m)
558 {
559         const char *id = astman_get_header(m,"ActionID");
560         char idText[256] = "";
561         const char *family = astman_get_header(m, "Family");
562         const char *key = astman_get_header(m, "Key");
563         char tmp[256];
564         int res;
565
566         if (ast_strlen_zero(family)) {
567                 astman_send_error(s, m, "No family specified.");
568                 return 0;
569         }
570         if (ast_strlen_zero(key)) {
571                 astman_send_error(s, m, "No key specified.");
572                 return 0;
573         }
574
575         if (!ast_strlen_zero(id))
576                 snprintf(idText, sizeof(idText) ,"ActionID: %s\r\n", id);
577
578         res = ast_db_get(family, key, tmp, sizeof(tmp));
579         if (res) {
580                 astman_send_error(s, m, "Database entry not found");
581         } else {
582                 astman_send_ack(s, m, "Result will follow");
583                 astman_append(s, "Event: DBGetResponse\r\n"
584                                 "Family: %s\r\n"
585                                 "Key: %s\r\n"
586                                 "Val: %s\r\n"
587                                 "%s"
588                                 "\r\n",
589                                 family, key, tmp, idText);
590         }
591         return 0;
592 }
593
594 static int manager_dbdel(struct mansession *s, const struct message *m)
595 {
596         const char *family = astman_get_header(m, "Family");
597         const char *key = astman_get_header(m, "Key");
598         int res;
599
600         if (ast_strlen_zero(family)) {
601                 astman_send_error(s, m, "No family specified.");
602                 return 0;
603         }
604
605         if (ast_strlen_zero(key)) {
606                 astman_send_error(s, m, "No key specified.");
607                 return 0;
608         }
609
610         res = ast_db_del(family, key);
611         if (res)
612                 astman_send_error(s, m, "Database entry not found");
613         else
614                 astman_send_ack(s, m, "Key deleted successfully");
615
616         return 0;
617 }
618
619 static int manager_dbdeltree(struct mansession *s, const struct message *m)
620 {
621         const char *family = astman_get_header(m, "Family");
622         const char *key = astman_get_header(m, "Key");
623         int res;
624
625         if (ast_strlen_zero(family)) {
626                 astman_send_error(s, m, "No family specified.");
627                 return 0;
628         }
629
630         if (!ast_strlen_zero(key))
631                 res = ast_db_deltree(family, key);
632         else
633                 res = ast_db_deltree(family, NULL);
634
635         if (res)
636                 astman_send_error(s, m, "Database entry not found");
637         else
638                 astman_send_ack(s, m, "Key tree deleted successfully");
639         
640         return 0;
641 }
642
643 int astdb_init(void)
644 {
645         dbinit();
646         ast_cli_register_multiple(cli_database, sizeof(cli_database) / sizeof(struct ast_cli_entry));
647         ast_manager_register("DBGet", EVENT_FLAG_SYSTEM, manager_dbget, "Get DB Entry");
648         ast_manager_register("DBPut", EVENT_FLAG_SYSTEM, manager_dbput, "Put DB Entry");
649         ast_manager_register("DBDel", EVENT_FLAG_SYSTEM, manager_dbdel, "Delete DB Entry");
650         ast_manager_register("DBDelTree", EVENT_FLAG_SYSTEM, manager_dbdeltree, "Delete DB Tree");
651         return 0;
652 }