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