fix some formatting and add some comments (issue #5403)
[asterisk/asterisk.git] / 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 /*
20  *
21  * Channel Management
22  * 
23  *
24  * DB3 is licensed under Sleepycat Public License and is thus incompatible
25  * with GPL.  To avoid having to make another exception (and complicate 
26  * licensing even further) we elect to use DB1 which is BSD licensed 
27  */
28
29
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <sys/time.h>
34 #include <signal.h>
35 #include <errno.h>
36 #include <unistd.h>
37 #include <dirent.h>
38
39 #include "asterisk.h"
40
41 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
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 static DB *astdb;
57 AST_MUTEX_DEFINE_STATIC(dblock);
58
59 static int dbinit(void) 
60 {
61         if (!astdb) {
62                 if (!(astdb = dbopen((char *)ast_config_AST_DB, O_CREAT | O_RDWR, 0664, DB_BTREE, NULL))) {
63                         ast_log(LOG_WARNING, "Unable to open Asterisk database\n");
64                 }
65         }
66         if (astdb)
67                 return 0;
68         return -1;
69 }
70
71
72 static inline int keymatch(const char *key, const char *prefix)
73 {
74         int preflen = strlen(prefix);
75         if (!preflen)
76                 return 1;
77         if (!strcasecmp(key, prefix))
78                 return 1;
79         if ((strlen(key) > preflen) && !strncasecmp(key, prefix, preflen)) {
80                 if (key[preflen] == '/')
81                         return 1;
82         }
83         return 0;
84 }
85
86 static inline int subkeymatch(const char *key, const char *suffix)
87 {
88         int suffixlen = strlen(suffix);
89         if (suffixlen) {
90                 const char *subkey = key + strlen(key) - suffixlen;
91                 if (subkey < key)
92                         return 0;
93                 if (!strcasecmp(subkey, suffix))
94                         return 1;
95         }
96         return 0;
97 }
98
99 int ast_db_deltree(const char *family, const char *keytree)
100 {
101         char prefix[256];
102         DBT key, data;
103         char *keys;
104         int res;
105         int pass;
106         
107         if (family) {
108                 if (keytree) {
109                         snprintf(prefix, sizeof(prefix), "/%s/%s", family, keytree);
110                 } else {
111                         snprintf(prefix, sizeof(prefix), "/%s", family);
112                 }
113         } else if (keytree) {
114                 return -1;
115         } else {
116                 prefix[0] = '\0';
117         }
118         
119         ast_mutex_lock(&dblock);
120         if (dbinit()) 
121                 return -1;
122         
123         memset(&key, 0, sizeof(key));
124         memset(&data, 0, sizeof(data));
125         pass = 0;
126         while (!(res = astdb->seq(astdb, &key, &data, pass++ ? R_NEXT : R_FIRST))) {
127                 if (key.size) {
128                         keys = key.data;
129                         keys[key.size - 1] = '\0';
130                 } else {
131                         keys = "<bad key>";
132                 }
133                 if (keymatch(keys, prefix)) {
134                         astdb->del(astdb, &key, 0);
135                 }
136         }
137         astdb->sync(astdb, 0);
138         ast_mutex_unlock(&dblock);
139         return 0;
140 }
141
142 int ast_db_put(const char *family, const char *keys, char *value)
143 {
144         char fullkey[256];
145         DBT key, data;
146         int res, fullkeylen;
147
148         ast_mutex_lock(&dblock);
149         if (dbinit()) {
150                 ast_mutex_unlock(&dblock);
151                 return -1;
152         }
153
154         fullkeylen = snprintf(fullkey, sizeof(fullkey), "/%s/%s", family, keys);
155         memset(&key, 0, sizeof(key));
156         memset(&data, 0, sizeof(data));
157         key.data = fullkey;
158         key.size = fullkeylen + 1;
159         data.data = value;
160         data.size = strlen(value) + 1;
161         res = astdb->put(astdb, &key, &data, 0);
162         astdb->sync(astdb, 0);
163         ast_mutex_unlock(&dblock);
164         if (res)
165                 ast_log(LOG_WARNING, "Unable to put value '%s' for key '%s' in family '%s'\n", value, keys, family);
166         return res;
167 }
168
169 int ast_db_get(const char *family, const char *keys, char *value, int valuelen)
170 {
171         char fullkey[256] = "";
172         DBT key, data;
173         int res, fullkeylen;
174
175         ast_mutex_lock(&dblock);
176         if (dbinit()) {
177                 ast_mutex_unlock(&dblock);
178                 return -1;
179         }
180
181         fullkeylen = snprintf(fullkey, sizeof(fullkey), "/%s/%s", family, keys);
182         memset(&key, 0, sizeof(key));
183         memset(&data, 0, sizeof(data));
184         memset(value, 0, valuelen);
185         key.data = fullkey;
186         key.size = fullkeylen + 1;
187         
188         res = astdb->get(astdb, &key, &data, 0);
189         
190         ast_mutex_unlock(&dblock);
191
192         /* Be sure to NULL terminate our data either way */
193         if (res) {
194                 ast_log(LOG_DEBUG, "Unable to find key '%s' in family '%s'\n", keys, family);
195         } else {
196 #if 0
197                 printf("Got value of size %d\n", data.size);
198 #endif
199                 if (data.size) {
200                         ((char *)data.data)[data.size - 1] = '\0';
201                         /* Make sure that we don't write too much to the dst pointer or we don't read too much from the source pointer */
202                         strncpy(value, data.data, (valuelen > data.size) ? data.size : valuelen);
203                         value[valuelen - 1] = '\0';
204                 } else {
205                         ast_log(LOG_NOTICE, "Strange, empty value for /%s/%s\n", family, keys);
206                 }
207         }
208         return res;
209 }
210
211 int ast_db_del(const char *family, const char *keys)
212 {
213         char fullkey[256];
214         DBT key;
215         int res, fullkeylen;
216
217         ast_mutex_lock(&dblock);
218         if (dbinit()) {
219                 ast_mutex_unlock(&dblock);
220                 return -1;
221         }
222         
223         fullkeylen = snprintf(fullkey, sizeof(fullkey), "/%s/%s", family, keys);
224         memset(&key, 0, sizeof(key));
225         key.data = fullkey;
226         key.size = fullkeylen + 1;
227         
228         res = astdb->del(astdb, &key, 0);
229         astdb->sync(astdb, 0);
230         
231         ast_mutex_unlock(&dblock);
232
233         if (res) 
234                 ast_log(LOG_DEBUG, "Unable to find key '%s' in family '%s'\n", keys, family);
235         return res;
236 }
237
238 static int database_put(int fd, int argc, char *argv[])
239 {
240         int res;
241         if (argc != 5)
242                 return RESULT_SHOWUSAGE;
243         res = ast_db_put(argv[2], argv[3], argv[4]);
244         if (res)  {
245                 ast_cli(fd, "Failed to update entry\n");
246         } else {
247                 ast_cli(fd, "Updated database successfully\n");
248         }
249         return RESULT_SUCCESS;
250 }
251
252 static int database_get(int fd, int argc, char *argv[])
253 {
254         int res;
255         char tmp[256];
256         if (argc != 4)
257                 return RESULT_SHOWUSAGE;
258         res = ast_db_get(argv[2], argv[3], tmp, sizeof(tmp));
259         if (res) {
260                 ast_cli(fd, "Database entry not found.\n");
261         } else {
262                 ast_cli(fd, "Value: %s\n", tmp);
263         }
264         return RESULT_SUCCESS;
265 }
266
267 static int database_del(int fd, int argc, char *argv[])
268 {
269         int res;
270         if (argc != 4)
271                 return RESULT_SHOWUSAGE;
272         res = ast_db_del(argv[2], argv[3]);
273         if (res) {
274                 ast_cli(fd, "Database entry does not exist.\n");
275         } else {
276                 ast_cli(fd, "Database entry removed.\n");
277         }
278         return RESULT_SUCCESS;
279 }
280
281 static int database_deltree(int fd, int argc, char *argv[])
282 {
283         int res;
284         if ((argc < 3) || (argc > 4))
285                 return RESULT_SHOWUSAGE;
286         if (argc == 4) {
287                 res = ast_db_deltree(argv[2], argv[3]);
288         } else {
289                 res = ast_db_deltree(argv[2], NULL);
290         }
291         if (res) {
292                 ast_cli(fd, "Database entries do not exist.\n");
293         } else {
294                 ast_cli(fd, "Database entries removed.\n");
295         }
296         return RESULT_SUCCESS;
297 }
298
299 static int database_show(int fd, int argc, char *argv[])
300 {
301         char prefix[256];
302         DBT key, data;
303         char *keys, *values;
304         int res;
305         int pass;
306
307         if (argc == 4) {
308                 /* Family and key tree */
309                 snprintf(prefix, sizeof(prefix), "/%s/%s", argv[2], argv[3]);
310         } else if (argc == 3) {
311                 /* Family only */
312                 snprintf(prefix, sizeof(prefix), "/%s", argv[2]);
313         } else if (argc == 2) {
314                 /* Neither */
315                 prefix[0] = '\0';
316         } else {
317                 return RESULT_SHOWUSAGE;
318         }
319         ast_mutex_lock(&dblock);
320         if (dbinit()) {
321                 ast_mutex_unlock(&dblock);
322                 ast_cli(fd, "Database unavailable\n");
323                 return RESULT_SUCCESS;  
324         }
325         memset(&key, 0, sizeof(key));
326         memset(&data, 0, sizeof(data));
327         pass = 0;
328         while (!(res = astdb->seq(astdb, &key, &data, pass++ ? R_NEXT : R_FIRST))) {
329                 if (key.size) {
330                         keys = key.data;
331                         keys[key.size - 1] = '\0';
332                 } else {
333                         keys = "<bad key>";
334                 }
335                 if (data.size) {
336                         values = data.data;
337                         values[data.size - 1]='\0';
338                 } else {
339                         values = "<bad value>";
340                 }
341                 if (keymatch(keys, prefix)) {
342                                 ast_cli(fd, "%-50s: %-25s\n", keys, values);
343                 }
344         }
345         ast_mutex_unlock(&dblock);
346         return RESULT_SUCCESS;  
347 }
348
349 static int database_showkey(int fd, int argc, char *argv[])
350 {
351         char suffix[256];
352         DBT key, data;
353         char *keys, *values;
354         int res;
355         int pass;
356
357         if (argc == 3) {
358                 /* Key only */
359                 snprintf(suffix, sizeof(suffix), "/%s", argv[2]);
360         } else {
361                 return RESULT_SHOWUSAGE;
362         }
363         ast_mutex_lock(&dblock);
364         if (dbinit()) {
365                 ast_mutex_unlock(&dblock);
366                 ast_cli(fd, "Database unavailable\n");
367                 return RESULT_SUCCESS;  
368         }
369         memset(&key, 0, sizeof(key));
370         memset(&data, 0, sizeof(data));
371         pass = 0;
372         while (!(res = astdb->seq(astdb, &key, &data, pass++ ? R_NEXT : R_FIRST))) {
373                 if (key.size) {
374                         keys = key.data;
375                         keys[key.size - 1] = '\0';
376                 } else {
377                         keys = "<bad key>";
378                 }
379                 if (data.size) {
380                         values = data.data;
381                         values[data.size - 1]='\0';
382                 } else {
383                         values = "<bad value>";
384                 }
385                 if (subkeymatch(keys, suffix)) {
386                                 ast_cli(fd, "%-50s: %-25s\n", keys, values);
387                 }
388         }
389         ast_mutex_unlock(&dblock);
390         return RESULT_SUCCESS;  
391 }
392
393 struct ast_db_entry *ast_db_gettree(const char *family, const char *keytree)
394 {
395         char prefix[256];
396         DBT key, data;
397         char *keys, *values;
398         int res;
399         int pass;
400         struct ast_db_entry *last = NULL;
401         struct ast_db_entry *cur, *ret=NULL;
402
403         if (family && !ast_strlen_zero(family)) {
404                 if (keytree && !ast_strlen_zero(keytree)) {
405                         /* Family and key tree */
406                         snprintf(prefix, sizeof(prefix), "/%s/%s", family, prefix);
407                 } else {
408                         /* Family only */
409                         snprintf(prefix, sizeof(prefix), "/%s", family);
410                 }
411         } else {
412                 prefix[0] = '\0';
413         }
414         ast_mutex_lock(&dblock);
415         if (dbinit()) {
416                 ast_mutex_unlock(&dblock);
417                 ast_log(LOG_WARNING, "Database unavailable\n");
418                 return NULL;    
419         }
420         memset(&key, 0, sizeof(key));
421         memset(&data, 0, sizeof(data));
422         pass = 0;
423         while (!(res = astdb->seq(astdb, &key, &data, pass++ ? R_NEXT : R_FIRST))) {
424                 if (key.size) {
425                         keys = key.data;
426                         keys[key.size - 1] = '\0';
427                 } else {
428                         keys = "<bad key>";
429                 }
430                 if (data.size) {
431                         values = data.data;
432                         values[data.size - 1] = '\0';
433                 } else {
434                         values = "<bad value>";
435                 }
436                 if (keymatch(keys, prefix)) {
437                         cur = malloc(sizeof(struct ast_db_entry) + strlen(keys) + strlen(values) + 2);
438                         if (cur) {
439                                 cur->next = NULL;
440                                 cur->key = cur->data + strlen(values) + 1;
441                                 strcpy(cur->data, values);
442                                 strcpy(cur->key, keys);
443                                 if (last) {
444                                         last->next = cur;
445                                 } else {
446                                         ret = cur;
447                                 }
448                                 last = cur;
449                         }
450                 }
451         }
452         ast_mutex_unlock(&dblock);
453         return ret;     
454 }
455
456 void ast_db_freetree(struct ast_db_entry *dbe)
457 {
458         struct ast_db_entry *last;
459         while (dbe) {
460                 last = dbe;
461                 dbe = dbe->next;
462                 free(last);
463         }
464 }
465
466 static char database_show_usage[] =
467 "Usage: database show [family [keytree]]\n"
468 "       Shows Asterisk database contents, optionally restricted\n"
469 "to a given family, or family and keytree.\n";
470
471 static char database_showkey_usage[] =
472 "Usage: database showkey <keytree>\n"
473 "       Shows Asterisk database contents, restricted to a given key.\n";
474
475 static char database_put_usage[] =
476 "Usage: database put <family> <key> <value>\n"
477 "       Adds or updates an entry in the Asterisk database for\n"
478 "a given family, key, and value.\n";
479
480 static char database_get_usage[] =
481 "Usage: database get <family> <key>\n"
482 "       Retrieves an entry in the Asterisk database for a given\n"
483 "family and key.\n";
484
485 static char database_del_usage[] =
486 "Usage: database del <family> <key>\n"
487 "       Deletes an entry in the Asterisk database for a given\n"
488 "family and key.\n";
489
490 static char database_deltree_usage[] =
491 "Usage: database deltree <family> [keytree]\n"
492 "       Deletes a family or specific keytree within a family\n"
493 "in the Asterisk database.\n";
494
495 struct ast_cli_entry cli_database_show =
496 { { "database", "show", NULL }, database_show, "Shows database contents", database_show_usage };
497
498 struct ast_cli_entry cli_database_showkey =
499 { { "database", "showkey", NULL }, database_showkey, "Shows database contents", database_showkey_usage };
500
501 struct ast_cli_entry cli_database_get =
502 { { "database", "get", NULL }, database_get, "Gets database value", database_get_usage };
503
504 struct ast_cli_entry cli_database_put =
505 { { "database", "put", NULL }, database_put, "Adds/updates database value", database_put_usage };
506
507 struct ast_cli_entry cli_database_del =
508 { { "database", "del", NULL }, database_del, "Removes database key/value", database_del_usage };
509
510 struct ast_cli_entry cli_database_deltree =
511 { { "database", "deltree", NULL }, database_deltree, "Removes database keytree/values", database_deltree_usage };
512
513 static int manager_dbput(struct mansession *s, struct message *m)
514 {
515         char *family = astman_get_header(m, "Family");
516         char *key = astman_get_header(m, "Key");
517         char *val = astman_get_header(m, "Val");
518         int res;
519
520         if (!strlen(family)) {
521                 astman_send_error(s, m, "No family specified");
522                 return 0;
523         }
524         if (!strlen(key)) {
525                 astman_send_error(s, m, "No key specified");
526                 return 0;
527         }
528         if (!strlen(val)) {
529                 astman_send_error(s, m, "No val specified");
530                 return 0;
531         }
532
533         res = ast_db_put(family, key, val);
534         if (res) {
535                 astman_send_error(s, m, "Failed to update entry");
536         } else {
537                 astman_send_ack(s, m, "Updated database successfully");
538         }
539         return 0;
540 }
541
542 static int manager_dbget(struct mansession *s, struct message *m)
543 {
544         char *id = astman_get_header(m,"ActionID");
545         char idText[256] = "";
546         char *family = astman_get_header(m, "Family");
547         char *key = astman_get_header(m, "Key");
548         char tmp[256];
549         int res;
550
551         if (!strlen(family)) {
552                 astman_send_error(s, m, "No family specified.");
553                 return 0;
554         }
555         if (!strlen(key)) {
556                 astman_send_error(s, m, "No key specified.");
557                 return 0;
558         }
559
560         if (id && !ast_strlen_zero(id))
561                 snprintf(idText, sizeof(idText) ,"ActionID: %s\r\n", id);
562
563         res = ast_db_get(family, key, tmp, sizeof(tmp));
564         if (res) {
565                 astman_send_error(s, m, "Database entry not found");
566         } else {
567                 astman_send_ack(s, m, "Result will follow");
568                 ast_cli(s->fd, "Event: DBGetResponse\r\n"
569                                 "Family: %s\r\n"
570                                 "Key: %s\r\n"
571                                 "Val: %s\r\n"
572                                 "%s"
573                                 "\r\n",
574                                 family, key, tmp, idText);
575         }
576         return 0;
577 }
578
579 int astdb_init(void)
580 {
581         dbinit();
582         ast_cli_register(&cli_database_show);
583         ast_cli_register(&cli_database_showkey);
584         ast_cli_register(&cli_database_get);
585         ast_cli_register(&cli_database_put);
586         ast_cli_register(&cli_database_del);
587         ast_cli_register(&cli_database_deltree);
588         ast_manager_register("DBGet", EVENT_FLAG_SYSTEM, manager_dbget, "Get DB Entry");
589         ast_manager_register("DBPut", EVENT_FLAG_SYSTEM, manager_dbput, "Put DB Entry");
590         return 0;
591 }