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