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