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