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         ast_mutex_unlock(&dblock);
 187
 188         /* Be sure to NULL terminate our data either way */
 189         if (res) {
 190                 ast_debug(1, "Unable to find key '%s' in family '%s'\n", keys, family);
 191         } else {
 192 #if 0
 193                 printf("Got value of size %d\n", data.size);
 194 #endif
 195                 if (data.size) {
 196                         ((char *)data.data)[data.size - 1] = '\0';
 197                         /* Make sure that we don't write too much to the dst pointer or we don't read too much from the source pointer */
 198                         ast_copy_string(value, data.data, (valuelen > data.size) ? data.size : valuelen);
 199                 } else {
 200                         ast_log(LOG_NOTICE, "Strange, empty value for /%s/%s\n", family, keys);
 201                 }
 202         }
 203         return res;
 204 }
 205
 206 int ast_db_del(const char *family, const char *keys)
 207 {
 208         char fullkey[256];
 209         DBT key;
 210         int res, fullkeylen;
 211
 212         ast_mutex_lock(&dblock);
 213         if (dbinit()) {
 214                 ast_mutex_unlock(&dblock);
 215                 return -1;
 216         }
 217
 218         fullkeylen = snprintf(fullkey, sizeof(fullkey), "/%s/%s", family, keys);
 219         memset(&key, 0, sizeof(key));
 220         key.data = fullkey;
 221         key.size = fullkeylen + 1;
 222
 223         res = astdb->del(astdb, &key, 0);
 224         astdb->sync(astdb, 0);
 225
 226         ast_mutex_unlock(&dblock);
 227
 228         if (res) {
 229                 ast_debug(1, "Unable to find key '%s' in family '%s'\n", keys, family);
 230         }
 231         return res;
 232 }
 233
 234 static char *handle_cli_database_put(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 235 {
 236         int res;
 237
 238         switch (cmd) {
 239         case CLI_INIT:
 240                 e->command = "database put";
 241                 e->usage =
 242                         "Usage: database put <family> <key> <value>\n"
 243                         "       Adds or updates an entry in the Asterisk database for\n"
 244                         "       a given family, key, and value.\n";
 245                 return NULL;
 246         case CLI_GENERATE:
 247                 return NULL;
 248         }
 249
 250         if (a->argc != 5)
 251                 return CLI_SHOWUSAGE;
 252         res = ast_db_put(a->argv[2], a->argv[3], a->argv[4]);
 253         if (res)  {
 254                 ast_cli(a->fd, "Failed to update entry\n");
 255         } else {
 256                 ast_cli(a->fd, "Updated database successfully\n");
 257         }
 258         return CLI_SUCCESS;
 259 }
 260
 261 static char *handle_cli_database_get(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 262 {
 263         int res;
 264         char tmp[256];
 265
 266         switch (cmd) {
 267         case CLI_INIT:
 268                 e->command = "database get";
 269                 e->usage =
 270                         "Usage: database get <family> <key>\n"
 271                         "       Retrieves an entry in the Asterisk database for a given\n"
 272                         "       family and key.\n";
 273                 return NULL;
 274         case CLI_GENERATE:
 275                 return NULL;
 276         }
 277
 278         if (a->argc != 4)
 279                 return CLI_SHOWUSAGE;
 280         res = ast_db_get(a->argv[2], a->argv[3], tmp, sizeof(tmp));
 281         if (res) {
 282                 ast_cli(a->fd, "Database entry not found.\n");
 283         } else {
 284                 ast_cli(a->fd, "Value: %s\n", tmp);
 285         }
 286         return CLI_SUCCESS;
 287 }
 288
 289 static char *handle_cli_database_del(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 290 {
 291         int res;
 292
 293         switch (cmd) {
 294         case CLI_INIT:
 295                 e->command = "database del";
 296                 e->usage =
 297                         "Usage: database del <family> <key>\n"
 298                         "       Deletes an entry in the Asterisk database for a given\n"
 299                         "       family and key.\n";
 300                 return NULL;
 301         case CLI_GENERATE:
 302                 return NULL;
 303         }
 304
 305         if (a->argc != 4)
 306                 return CLI_SHOWUSAGE;
 307         res = ast_db_del(a->argv[2], a->argv[3]);
 308         if (res) {
 309                 ast_cli(a->fd, "Database entry does not exist.\n");
 310         } else {
 311                 ast_cli(a->fd, "Database entry removed.\n");
 312         }
 313         return CLI_SUCCESS;
 314 }
 315
 316 static char *handle_cli_database_deltree(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 317 {
 318         int res;
 319
 320         switch (cmd) {
 321         case CLI_INIT:
 322                 e->command = "database deltree";
 323                 e->usage =
 324                         "Usage: database deltree <family> [keytree]\n"
 325                         "       Deletes a family or specific keytree within a family\n"
 326                         "       in the Asterisk database.\n";
 327                 return NULL;
 328         case CLI_GENERATE:
 329                 return NULL;
 330         }
 331
 332         if ((a->argc < 3) || (a->argc > 4))
 333                 return CLI_SHOWUSAGE;
 334         if (a->argc == 4) {
 335                 res = ast_db_deltree(a->argv[2], a->argv[3]);
 336         } else {
 337                 res = ast_db_deltree(a->argv[2], NULL);
 338         }
 339         if (res < 0) {
 340                 ast_cli(a->fd, "Database entries do not exist.\n");
 341         } else {
 342                 ast_cli(a->fd, "%d database entries removed.\n",res);
 343         }
 344         return CLI_SUCCESS;
 345 }
 346
 347 static char *handle_cli_database_show(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 348 {
 349         char prefix[256];
 350         DBT key, data;
 351         char *keys, *values;
 352         int res;
 353         int pass;
 354         int counter = 0;
 355
 356         switch (cmd) {
 357         case CLI_INIT:
 358                 e->command = "database show";
 359                 e->usage =
 360                         "Usage: database show [family [keytree]]\n"
 361                         "       Shows Asterisk database contents, optionally restricted\n"
 362                         "       to a given family, or family and keytree.\n";
 363                 return NULL;
 364         case CLI_GENERATE:
 365                 return NULL;
 366         }
 367
 368         if (a->argc == 4) {
 369                 /* Family and key tree */
 370                 snprintf(prefix, sizeof(prefix), "/%s/%s", a->argv[2], a->argv[3]);
 371         } else if (a->argc == 3) {
 372                 /* Family only */
 373                 snprintf(prefix, sizeof(prefix), "/%s", a->argv[2]);
 374         } else if (a->argc == 2) {
 375                 /* Neither */
 376                 prefix[0] = '\0';
 377         } else {
 378                 return CLI_SHOWUSAGE;
 379         }
 380         ast_mutex_lock(&dblock);
 381         if (dbinit()) {
 382                 ast_mutex_unlock(&dblock);
 383                 ast_cli(a->fd, "Database unavailable\n");
 384                 return CLI_SUCCESS;
 385         }
 386         memset(&key, 0, sizeof(key));
 387         memset(&data, 0, sizeof(data));
 388         pass = 0;
 389         while (!(res = astdb->seq(astdb, &key, &data, pass++ ? R_NEXT : R_FIRST))) {
 390                 if (key.size) {
 391                         keys = key.data;
 392                         keys[key.size - 1] = '\0';
 393                 } else {
 394                         keys = "<bad key>";
 395                 }
 396                 if (data.size) {
 397                         values = data.data;
 398                         values[data.size - 1]='\0';
 399                 } else {
 400                         values = "<bad value>";
 401                 }
 402                 if (keymatch(keys, prefix)) {
 403                         ast_cli(a->fd, "%-50s: %-25s\n", keys, values);
 404                         counter++;
 405                 }
 406         }
 407         ast_mutex_unlock(&dblock);
 408         ast_cli(a->fd, "%d results found.\n", counter);
 409         return CLI_SUCCESS;
 410 }
 411
 412 static char *handle_cli_database_showkey(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 413 {
 414         char suffix[256];
 415         DBT key, data;
 416         char *keys, *values;
 417         int res;
 418         int pass;
 419         int counter = 0;
 420
 421         switch (cmd) {
 422         case CLI_INIT:
 423                 e->command = "database showkey";
 424                 e->usage =
 425                         "Usage: database showkey <keytree>\n"
 426                         "       Shows Asterisk database contents, restricted to a given key.\n";
 427                 return NULL;
 428         case CLI_GENERATE:
 429                 return NULL;
 430         }
 431
 432         if (a->argc == 3) {
 433                 /* Key only */
 434                 snprintf(suffix, sizeof(suffix), "/%s", a->argv[2]);
 435         } else {
 436                 return CLI_SHOWUSAGE;
 437         }
 438         ast_mutex_lock(&dblock);
 439         if (dbinit()) {
 440                 ast_mutex_unlock(&dblock);
 441                 ast_cli(a->fd, "Database unavailable\n");
 442                 return CLI_SUCCESS;
 443         }
 444         memset(&key, 0, sizeof(key));
 445         memset(&data, 0, sizeof(data));
 446         pass = 0;
 447         while (!(res = astdb->seq(astdb, &key, &data, pass++ ? R_NEXT : R_FIRST))) {
 448                 if (key.size) {
 449                         keys = key.data;
 450                         keys[key.size - 1] = '\0';
 451                 } else {
 452                         keys = "<bad key>";
 453                 }
 454                 if (data.size) {
 455                         values = data.data;
 456                         values[data.size - 1]='\0';
 457                 } else {
 458                         values = "<bad value>";
 459                 }
 460                 if (subkeymatch(keys, suffix)) {
 461                         ast_cli(a->fd, "%-50s: %-25s\n", keys, values);
 462                         counter++;
 463                 }
 464         }
 465         ast_mutex_unlock(&dblock);
 466         ast_cli(a->fd, "%d results found.\n", counter);
 467         return CLI_SUCCESS;
 468 }
 469
 470 struct ast_db_entry *ast_db_gettree(const char *family, const char *keytree)
 471 {
 472         char prefix[256];
 473         DBT key, data;
 474         char *keys, *values;
 475         int values_len;
 476         int res;
 477         int pass;
 478         struct ast_db_entry *last = NULL;
 479         struct ast_db_entry *cur, *ret=NULL;
 480
 481         if (!ast_strlen_zero(family)) {
 482                 if (!ast_strlen_zero(keytree)) {
 483                         /* Family and key tree */
 484                         snprintf(prefix, sizeof(prefix), "/%s/%s", family, prefix);
 485                 } else {
 486                         /* Family only */
 487                         snprintf(prefix, sizeof(prefix), "/%s", family);
 488                 }
 489         } else {
 490                 prefix[0] = '\0';
 491         }
 492         ast_mutex_lock(&dblock);
 493         if (dbinit()) {
 494                 ast_mutex_unlock(&dblock);
 495                 ast_log(LOG_WARNING, "Database unavailable\n");
 496                 return NULL;
 497         }
 498         memset(&key, 0, sizeof(key));
 499         memset(&data, 0, sizeof(data));
 500         pass = 0;
 501         while (!(res = astdb->seq(astdb, &key, &data, pass++ ? R_NEXT : R_FIRST))) {
 502                 if (key.size) {
 503                         keys = key.data;
 504                         keys[key.size - 1] = '\0';
 505                 } else {
 506                         keys = "<bad key>";
 507                 }
 508                 if (data.size) {
 509                         values = data.data;
 510                         values[data.size - 1] = '\0';
 511                 } else {
 512                         values = "<bad value>";
 513                 }
 514                 values_len = strlen(values) + 1;
 515                 if (keymatch(keys, prefix) && (cur = ast_malloc(sizeof(*cur) + strlen(keys) + 1 + values_len))) {
 516                         cur->next = NULL;
 517                         cur->key = cur->data + values_len;
 518                         strcpy(cur->data, values);
 519                         strcpy(cur->key, keys);
 520                         if (last) {
 521                                 last->next = cur;
 522                         } else {
 523                                 ret = cur;
 524                         }
 525                         last = cur;
 526                 }
 527         }
 528         ast_mutex_unlock(&dblock);
 529         return ret;
 530 }
 531
 532 void ast_db_freetree(struct ast_db_entry *dbe)
 533 {
 534         struct ast_db_entry *last;
 535         while (dbe) {
 536                 last = dbe;
 537                 dbe = dbe->next;
 538                 ast_free(last);
 539         }
 540 }
 541
 542 struct ast_cli_entry cli_database[] = {
 543         AST_CLI_DEFINE(handle_cli_database_show,    "Shows database contents"),
 544         AST_CLI_DEFINE(handle_cli_database_showkey, "Shows database contents"),
 545         AST_CLI_DEFINE(handle_cli_database_get,     "Gets database value"),
 546         AST_CLI_DEFINE(handle_cli_database_put,     "Adds/updates database value"),
 547         AST_CLI_DEFINE(handle_cli_database_del,     "Removes database key/value"),
 548         AST_CLI_DEFINE(handle_cli_database_deltree, "Removes database keytree/values")
 549 };
 550
 551 static int manager_dbput(struct mansession *s, const struct message *m)
 552 {
 553         const char *family = astman_get_header(m, "Family");
 554         const char *key = astman_get_header(m, "Key");
 555         const char *val = astman_get_header(m, "Val");
 556         int res;
 557
 558         if (ast_strlen_zero(family)) {
 559                 astman_send_error(s, m, "No family specified");
 560                 return 0;
 561         }
 562         if (ast_strlen_zero(key)) {
 563                 astman_send_error(s, m, "No key specified");
 564                 return 0;
 565         }
 566
 567         res = ast_db_put(family, key, S_OR(val, ""));
 568         if (res) {
 569                 astman_send_error(s, m, "Failed to update entry");
 570         } else {
 571                 astman_send_ack(s, m, "Updated database successfully");
 572         }
 573         return 0;
 574 }
 575
 576 static int manager_dbget(struct mansession *s, const struct message *m)
 577 {
 578         const char *id = astman_get_header(m,"ActionID");
 579         char idText[256] = "";
 580         const char *family = astman_get_header(m, "Family");
 581         const char *key = astman_get_header(m, "Key");
 582         char tmp[256];
 583         int res;
 584
 585         if (ast_strlen_zero(family)) {
 586                 astman_send_error(s, m, "No family specified.");
 587                 return 0;
 588         }
 589         if (ast_strlen_zero(key)) {
 590                 astman_send_error(s, m, "No key specified.");
 591                 return 0;
 592         }
 593
 594         if (!ast_strlen_zero(id))
 595                 snprintf(idText, sizeof(idText) ,"ActionID: %s\r\n", id);
 596
 597         res = ast_db_get(family, key, tmp, sizeof(tmp));
 598         if (res) {
 599                 astman_send_error(s, m, "Database entry not found");
 600         } else {
 601                 astman_send_ack(s, m, "Result will follow");
 602                 astman_append(s, "Event: DBGetResponse\r\n"
 603                                 "Family: %s\r\n"
 604                                 "Key: %s\r\n"
 605                                 "Val: %s\r\n"
 606                                 "%s"
 607                                 "\r\n",
 608                                 family, key, tmp, idText);
 609         }
 610         return 0;
 611 }
 612
 613 static int manager_dbdel(struct mansession *s, const struct message *m)
 614 {
 615         const char *family = astman_get_header(m, "Family");
 616         const char *key = astman_get_header(m, "Key");
 617         int res;
 618
 619         if (ast_strlen_zero(family)) {
 620                 astman_send_error(s, m, "No family specified.");
 621                 return 0;
 622         }
 623
 624         if (ast_strlen_zero(key)) {
 625                 astman_send_error(s, m, "No key specified.");
 626                 return 0;
 627         }
 628
 629         res = ast_db_del(family, key);
 630         if (res)
 631                 astman_send_error(s, m, "Database entry not found");
 632         else
 633                 astman_send_ack(s, m, "Key deleted successfully");
 634
 635         return 0;
 636 }
 637
 638 static int manager_dbdeltree(struct mansession *s, const struct message *m)
 639 {
 640         const char *family = astman_get_header(m, "Family");
 641         const char *key = astman_get_header(m, "Key");
 642         int res;
 643
 644         if (ast_strlen_zero(family)) {
 645                 astman_send_error(s, m, "No family specified.");
 646                 return 0;
 647         }
 648
 649         if (!ast_strlen_zero(key))
 650                 res = ast_db_deltree(family, key);
 651         else
 652                 res = ast_db_deltree(family, NULL);
 653
 654         if (res < 0)
 655                 astman_send_error(s, m, "Database entry not found");
 656         else
 657                 astman_send_ack(s, m, "Key tree deleted successfully");
 658
 659         return 0;
 660 }
 661
 662 int astdb_init(void)
 663 {
 664         dbinit();
 665         ast_cli_register_multiple(cli_database, sizeof(cli_database) / sizeof(struct ast_cli_entry));
 666         ast_manager_register("DBGet", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, manager_dbget, "Get DB Entry");
 667         ast_manager_register("DBPut", EVENT_FLAG_SYSTEM, manager_dbput, "Put DB Entry");
 668         ast_manager_register("DBDel", EVENT_FLAG_SYSTEM, manager_dbdel, "Delete DB Entry");
 669         ast_manager_register("DBDelTree", EVENT_FLAG_SYSTEM, manager_dbdeltree, "Delete DB Tree");
 670         return 0;
 671 }