aboutsummaryrefslogtreecommitdiffstats
path: root/trunk/main/db.c
diff options
context:
space:
mode:
Diffstat (limited to 'trunk/main/db.c')
-rw-r--r--trunk/main/db.c671
1 files changed, 671 insertions, 0 deletions
diff --git a/trunk/main/db.c b/trunk/main/db.c
new file mode 100644
index 000000000..94bf4f001
--- /dev/null
+++ b/trunk/main/db.c
@@ -0,0 +1,671 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 1999 - 2005, Digium, Inc.
+ *
+ * Mark Spencer <markster@digium.com>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*! \file
+ *
+ * \brief ASTdb Management
+ *
+ * \author Mark Spencer <markster@digium.com>
+ *
+ * \note DB3 is licensed under Sleepycat Public License and is thus incompatible
+ * with GPL. To avoid having to make another exception (and complicate
+ * licensing even further) we elect to use DB1 which is BSD licensed
+ */
+
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+
+#include "asterisk/_private.h"
+#include "asterisk/paths.h" /* use ast_config_AST_DB */
+#include <sys/time.h>
+#include <signal.h>
+#include <dirent.h>
+
+#include "asterisk/channel.h"
+#include "asterisk/file.h"
+#include "asterisk/app.h"
+#include "asterisk/dsp.h"
+#include "asterisk/astdb.h"
+#include "asterisk/cli.h"
+#include "asterisk/utils.h"
+#include "asterisk/lock.h"
+#include "asterisk/manager.h"
+#include "db1-ast/include/db.h"
+
+static DB *astdb;
+AST_MUTEX_DEFINE_STATIC(dblock);
+
+static int dbinit(void)
+{
+ if (!astdb && !(astdb = dbopen(ast_config_AST_DB, O_CREAT | O_RDWR, AST_FILE_MODE, DB_BTREE, NULL))) {
+ ast_log(LOG_WARNING, "Unable to open Asterisk database '%s': %s\n", ast_config_AST_DB, strerror(errno));
+ return -1;
+ }
+ return 0;
+}
+
+
+static inline int keymatch(const char *key, const char *prefix)
+{
+ int preflen = strlen(prefix);
+ if (!preflen)
+ return 1;
+ if (!strcasecmp(key, prefix))
+ return 1;
+ if ((strlen(key) > preflen) && !strncasecmp(key, prefix, preflen)) {
+ if (key[preflen] == '/')
+ return 1;
+ }
+ return 0;
+}
+
+static inline int subkeymatch(const char *key, const char *suffix)
+{
+ int suffixlen = strlen(suffix);
+ if (suffixlen) {
+ const char *subkey = key + strlen(key) - suffixlen;
+ if (subkey < key)
+ return 0;
+ if (!strcasecmp(subkey, suffix))
+ return 1;
+ }
+ return 0;
+}
+
+int ast_db_deltree(const char *family, const char *keytree)
+{
+ char prefix[256];
+ DBT key, data;
+ char *keys;
+ int res;
+ int pass;
+ int counter = 0;
+
+ if (family) {
+ if (keytree) {
+ snprintf(prefix, sizeof(prefix), "/%s/%s", family, keytree);
+ } else {
+ snprintf(prefix, sizeof(prefix), "/%s", family);
+ }
+ } else if (keytree) {
+ return -1;
+ } else {
+ prefix[0] = '\0';
+ }
+
+ ast_mutex_lock(&dblock);
+ if (dbinit()) {
+ ast_mutex_unlock(&dblock);
+ return -1;
+ }
+
+ memset(&key, 0, sizeof(key));
+ memset(&data, 0, sizeof(data));
+ pass = 0;
+ while (!(res = astdb->seq(astdb, &key, &data, pass++ ? R_NEXT : R_FIRST))) {
+ if (key.size) {
+ keys = key.data;
+ keys[key.size - 1] = '\0';
+ } else {
+ keys = "<bad key>";
+ }
+ if (keymatch(keys, prefix)) {
+ astdb->del(astdb, &key, 0);
+ counter++;
+ }
+ }
+ astdb->sync(astdb, 0);
+ ast_mutex_unlock(&dblock);
+ return counter;
+}
+
+int ast_db_put(const char *family, const char *keys, const char *value)
+{
+ char fullkey[256];
+ DBT key, data;
+ int res, fullkeylen;
+
+ ast_mutex_lock(&dblock);
+ if (dbinit()) {
+ ast_mutex_unlock(&dblock);
+ return -1;
+ }
+
+ fullkeylen = snprintf(fullkey, sizeof(fullkey), "/%s/%s", family, keys);
+ memset(&key, 0, sizeof(key));
+ memset(&data, 0, sizeof(data));
+ key.data = fullkey;
+ key.size = fullkeylen + 1;
+ data.data = (char *) value;
+ data.size = strlen(value) + 1;
+ res = astdb->put(astdb, &key, &data, 0);
+ astdb->sync(astdb, 0);
+ ast_mutex_unlock(&dblock);
+ if (res)
+ ast_log(LOG_WARNING, "Unable to put value '%s' for key '%s' in family '%s'\n", value, keys, family);
+ return res;
+}
+
+int ast_db_get(const char *family, const char *keys, char *value, int valuelen)
+{
+ char fullkey[256] = "";
+ DBT key, data;
+ int res, fullkeylen;
+
+ ast_mutex_lock(&dblock);
+ if (dbinit()) {
+ ast_mutex_unlock(&dblock);
+ return -1;
+ }
+
+ fullkeylen = snprintf(fullkey, sizeof(fullkey), "/%s/%s", family, keys);
+ memset(&key, 0, sizeof(key));
+ memset(&data, 0, sizeof(data));
+ memset(value, 0, valuelen);
+ key.data = fullkey;
+ key.size = fullkeylen + 1;
+
+ res = astdb->get(astdb, &key, &data, 0);
+
+ ast_mutex_unlock(&dblock);
+
+ /* Be sure to NULL terminate our data either way */
+ if (res) {
+ ast_debug(1, "Unable to find key '%s' in family '%s'\n", keys, family);
+ } else {
+#if 0
+ printf("Got value of size %d\n", data.size);
+#endif
+ if (data.size) {
+ ((char *)data.data)[data.size - 1] = '\0';
+ /* Make sure that we don't write too much to the dst pointer or we don't read too much from the source pointer */
+ ast_copy_string(value, data.data, (valuelen > data.size) ? data.size : valuelen);
+ } else {
+ ast_log(LOG_NOTICE, "Strange, empty value for /%s/%s\n", family, keys);
+ }
+ }
+ return res;
+}
+
+int ast_db_del(const char *family, const char *keys)
+{
+ char fullkey[256];
+ DBT key;
+ int res, fullkeylen;
+
+ ast_mutex_lock(&dblock);
+ if (dbinit()) {
+ ast_mutex_unlock(&dblock);
+ return -1;
+ }
+
+ fullkeylen = snprintf(fullkey, sizeof(fullkey), "/%s/%s", family, keys);
+ memset(&key, 0, sizeof(key));
+ key.data = fullkey;
+ key.size = fullkeylen + 1;
+
+ res = astdb->del(astdb, &key, 0);
+ astdb->sync(astdb, 0);
+
+ ast_mutex_unlock(&dblock);
+
+ if (res) {
+ ast_debug(1, "Unable to find key '%s' in family '%s'\n", keys, family);
+ }
+ return res;
+}
+
+static char *handle_cli_database_put(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+ int res;
+
+ switch (cmd) {
+ case CLI_INIT:
+ e->command = "database put";
+ e->usage =
+ "Usage: database put <family> <key> <value>\n"
+ " Adds or updates an entry in the Asterisk database for\n"
+ " a given family, key, and value.\n";
+ return NULL;
+ case CLI_GENERATE:
+ return NULL;
+ }
+
+ if (a->argc != 5)
+ return CLI_SHOWUSAGE;
+ res = ast_db_put(a->argv[2], a->argv[3], a->argv[4]);
+ if (res) {
+ ast_cli(a->fd, "Failed to update entry\n");
+ } else {
+ ast_cli(a->fd, "Updated database successfully\n");
+ }
+ return CLI_SUCCESS;
+}
+
+static char *handle_cli_database_get(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+ int res;
+ char tmp[256];
+
+ switch (cmd) {
+ case CLI_INIT:
+ e->command = "database get";
+ e->usage =
+ "Usage: database get <family> <key>\n"
+ " Retrieves an entry in the Asterisk database for a given\n"
+ " family and key.\n";
+ return NULL;
+ case CLI_GENERATE:
+ return NULL;
+ }
+
+ if (a->argc != 4)
+ return CLI_SHOWUSAGE;
+ res = ast_db_get(a->argv[2], a->argv[3], tmp, sizeof(tmp));
+ if (res) {
+ ast_cli(a->fd, "Database entry not found.\n");
+ } else {
+ ast_cli(a->fd, "Value: %s\n", tmp);
+ }
+ return CLI_SUCCESS;
+}
+
+static char *handle_cli_database_del(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+ int res;
+
+ switch (cmd) {
+ case CLI_INIT:
+ e->command = "database del";
+ e->usage =
+ "Usage: database del <family> <key>\n"
+ " Deletes an entry in the Asterisk database for a given\n"
+ " family and key.\n";
+ return NULL;
+ case CLI_GENERATE:
+ return NULL;
+ }
+
+ if (a->argc != 4)
+ return CLI_SHOWUSAGE;
+ res = ast_db_del(a->argv[2], a->argv[3]);
+ if (res) {
+ ast_cli(a->fd, "Database entry does not exist.\n");
+ } else {
+ ast_cli(a->fd, "Database entry removed.\n");
+ }
+ return CLI_SUCCESS;
+}
+
+static char *handle_cli_database_deltree(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+ int res;
+
+ switch (cmd) {
+ case CLI_INIT:
+ e->command = "database deltree";
+ e->usage =
+ "Usage: database deltree <family> [keytree]\n"
+ " Deletes a family or specific keytree within a family\n"
+ " in the Asterisk database.\n";
+ return NULL;
+ case CLI_GENERATE:
+ return NULL;
+ }
+
+ if ((a->argc < 3) || (a->argc > 4))
+ return CLI_SHOWUSAGE;
+ if (a->argc == 4) {
+ res = ast_db_deltree(a->argv[2], a->argv[3]);
+ } else {
+ res = ast_db_deltree(a->argv[2], NULL);
+ }
+ if (res < 0) {
+ ast_cli(a->fd, "Database entries do not exist.\n");
+ } else {
+ ast_cli(a->fd, "%d database entries removed.\n",res);
+ }
+ return CLI_SUCCESS;
+}
+
+static char *handle_cli_database_show(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+ char prefix[256];
+ DBT key, data;
+ char *keys, *values;
+ int res;
+ int pass;
+ int counter = 0;
+
+ switch (cmd) {
+ case CLI_INIT:
+ e->command = "database show";
+ e->usage =
+ "Usage: database show [family [keytree]]\n"
+ " Shows Asterisk database contents, optionally restricted\n"
+ " to a given family, or family and keytree.\n";
+ return NULL;
+ case CLI_GENERATE:
+ return NULL;
+ }
+
+ if (a->argc == 4) {
+ /* Family and key tree */
+ snprintf(prefix, sizeof(prefix), "/%s/%s", a->argv[2], a->argv[3]);
+ } else if (a->argc == 3) {
+ /* Family only */
+ snprintf(prefix, sizeof(prefix), "/%s", a->argv[2]);
+ } else if (a->argc == 2) {
+ /* Neither */
+ prefix[0] = '\0';
+ } else {
+ return CLI_SHOWUSAGE;
+ }
+ ast_mutex_lock(&dblock);
+ if (dbinit()) {
+ ast_mutex_unlock(&dblock);
+ ast_cli(a->fd, "Database unavailable\n");
+ return CLI_SUCCESS;
+ }
+ memset(&key, 0, sizeof(key));
+ memset(&data, 0, sizeof(data));
+ pass = 0;
+ while (!(res = astdb->seq(astdb, &key, &data, pass++ ? R_NEXT : R_FIRST))) {
+ if (key.size) {
+ keys = key.data;
+ keys[key.size - 1] = '\0';
+ } else {
+ keys = "<bad key>";
+ }
+ if (data.size) {
+ values = data.data;
+ values[data.size - 1]='\0';
+ } else {
+ values = "<bad value>";
+ }
+ if (keymatch(keys, prefix)) {
+ ast_cli(a->fd, "%-50s: %-25s\n", keys, values);
+ counter++;
+ }
+ }
+ ast_mutex_unlock(&dblock);
+ ast_cli(a->fd, "%d results found.\n", counter);
+ return CLI_SUCCESS;
+}
+
+static char *handle_cli_database_showkey(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+ char suffix[256];
+ DBT key, data;
+ char *keys, *values;
+ int res;
+ int pass;
+ int counter = 0;
+
+ switch (cmd) {
+ case CLI_INIT:
+ e->command = "database showkey";
+ e->usage =
+ "Usage: database showkey <keytree>\n"
+ " Shows Asterisk database contents, restricted to a given key.\n";
+ return NULL;
+ case CLI_GENERATE:
+ return NULL;
+ }
+
+ if (a->argc == 3) {
+ /* Key only */
+ snprintf(suffix, sizeof(suffix), "/%s", a->argv[2]);
+ } else {
+ return CLI_SHOWUSAGE;
+ }
+ ast_mutex_lock(&dblock);
+ if (dbinit()) {
+ ast_mutex_unlock(&dblock);
+ ast_cli(a->fd, "Database unavailable\n");
+ return CLI_SUCCESS;
+ }
+ memset(&key, 0, sizeof(key));
+ memset(&data, 0, sizeof(data));
+ pass = 0;
+ while (!(res = astdb->seq(astdb, &key, &data, pass++ ? R_NEXT : R_FIRST))) {
+ if (key.size) {
+ keys = key.data;
+ keys[key.size - 1] = '\0';
+ } else {
+ keys = "<bad key>";
+ }
+ if (data.size) {
+ values = data.data;
+ values[data.size - 1]='\0';
+ } else {
+ values = "<bad value>";
+ }
+ if (subkeymatch(keys, suffix)) {
+ ast_cli(a->fd, "%-50s: %-25s\n", keys, values);
+ counter++;
+ }
+ }
+ ast_mutex_unlock(&dblock);
+ ast_cli(a->fd, "%d results found.\n", counter);
+ return CLI_SUCCESS;
+}
+
+struct ast_db_entry *ast_db_gettree(const char *family, const char *keytree)
+{
+ char prefix[256];
+ DBT key, data;
+ char *keys, *values;
+ int values_len;
+ int res;
+ int pass;
+ struct ast_db_entry *last = NULL;
+ struct ast_db_entry *cur, *ret=NULL;
+
+ if (!ast_strlen_zero(family)) {
+ if (!ast_strlen_zero(keytree)) {
+ /* Family and key tree */
+ snprintf(prefix, sizeof(prefix), "/%s/%s", family, prefix);
+ } else {
+ /* Family only */
+ snprintf(prefix, sizeof(prefix), "/%s", family);
+ }
+ } else {
+ prefix[0] = '\0';
+ }
+ ast_mutex_lock(&dblock);
+ if (dbinit()) {
+ ast_mutex_unlock(&dblock);
+ ast_log(LOG_WARNING, "Database unavailable\n");
+ return NULL;
+ }
+ memset(&key, 0, sizeof(key));
+ memset(&data, 0, sizeof(data));
+ pass = 0;
+ while (!(res = astdb->seq(astdb, &key, &data, pass++ ? R_NEXT : R_FIRST))) {
+ if (key.size) {
+ keys = key.data;
+ keys[key.size - 1] = '\0';
+ } else {
+ keys = "<bad key>";
+ }
+ if (data.size) {
+ values = data.data;
+ values[data.size - 1] = '\0';
+ } else {
+ values = "<bad value>";
+ }
+ values_len = strlen(values) + 1;
+ if (keymatch(keys, prefix) && (cur = ast_malloc(sizeof(*cur) + strlen(keys) + 1 + values_len))) {
+ cur->next = NULL;
+ cur->key = cur->data + values_len;
+ strcpy(cur->data, values);
+ strcpy(cur->key, keys);
+ if (last) {
+ last->next = cur;
+ } else {
+ ret = cur;
+ }
+ last = cur;
+ }
+ }
+ ast_mutex_unlock(&dblock);
+ return ret;
+}
+
+void ast_db_freetree(struct ast_db_entry *dbe)
+{
+ struct ast_db_entry *last;
+ while (dbe) {
+ last = dbe;
+ dbe = dbe->next;
+ ast_free(last);
+ }
+}
+
+struct ast_cli_entry cli_database[] = {
+ AST_CLI_DEFINE(handle_cli_database_show, "Shows database contents"),
+ AST_CLI_DEFINE(handle_cli_database_showkey, "Shows database contents"),
+ AST_CLI_DEFINE(handle_cli_database_get, "Gets database value"),
+ AST_CLI_DEFINE(handle_cli_database_put, "Adds/updates database value"),
+ AST_CLI_DEFINE(handle_cli_database_del, "Removes database key/value"),
+ AST_CLI_DEFINE(handle_cli_database_deltree, "Removes database keytree/values")
+};
+
+static int manager_dbput(struct mansession *s, const struct message *m)
+{
+ const char *family = astman_get_header(m, "Family");
+ const char *key = astman_get_header(m, "Key");
+ const char *val = astman_get_header(m, "Val");
+ int res;
+
+ if (ast_strlen_zero(family)) {
+ astman_send_error(s, m, "No family specified");
+ return 0;
+ }
+ if (ast_strlen_zero(key)) {
+ astman_send_error(s, m, "No key specified");
+ return 0;
+ }
+
+ res = ast_db_put(family, key, S_OR(val, ""));
+ if (res) {
+ astman_send_error(s, m, "Failed to update entry");
+ } else {
+ astman_send_ack(s, m, "Updated database successfully");
+ }
+ return 0;
+}
+
+static int manager_dbget(struct mansession *s, const struct message *m)
+{
+ const char *id = astman_get_header(m,"ActionID");
+ char idText[256] = "";
+ const char *family = astman_get_header(m, "Family");
+ const char *key = astman_get_header(m, "Key");
+ char tmp[256];
+ int res;
+
+ if (ast_strlen_zero(family)) {
+ astman_send_error(s, m, "No family specified.");
+ return 0;
+ }
+ if (ast_strlen_zero(key)) {
+ astman_send_error(s, m, "No key specified.");
+ return 0;
+ }
+
+ if (!ast_strlen_zero(id))
+ snprintf(idText, sizeof(idText) ,"ActionID: %s\r\n", id);
+
+ res = ast_db_get(family, key, tmp, sizeof(tmp));
+ if (res) {
+ astman_send_error(s, m, "Database entry not found");
+ } else {
+ astman_send_ack(s, m, "Result will follow");
+ astman_append(s, "Event: DBGetResponse\r\n"
+ "Family: %s\r\n"
+ "Key: %s\r\n"
+ "Val: %s\r\n"
+ "%s"
+ "\r\n",
+ family, key, tmp, idText);
+ }
+ return 0;
+}
+
+static int manager_dbdel(struct mansession *s, const struct message *m)
+{
+ const char *family = astman_get_header(m, "Family");
+ const char *key = astman_get_header(m, "Key");
+ int res;
+
+ if (ast_strlen_zero(family)) {
+ astman_send_error(s, m, "No family specified.");
+ return 0;
+ }
+
+ if (ast_strlen_zero(key)) {
+ astman_send_error(s, m, "No key specified.");
+ return 0;
+ }
+
+ res = ast_db_del(family, key);
+ if (res)
+ astman_send_error(s, m, "Database entry not found");
+ else
+ astman_send_ack(s, m, "Key deleted successfully");
+
+ return 0;
+}
+
+static int manager_dbdeltree(struct mansession *s, const struct message *m)
+{
+ const char *family = astman_get_header(m, "Family");
+ const char *key = astman_get_header(m, "Key");
+ int res;
+
+ if (ast_strlen_zero(family)) {
+ astman_send_error(s, m, "No family specified.");
+ return 0;
+ }
+
+ if (!ast_strlen_zero(key))
+ res = ast_db_deltree(family, key);
+ else
+ res = ast_db_deltree(family, NULL);
+
+ if (res < 0)
+ astman_send_error(s, m, "Database entry not found");
+ else
+ astman_send_ack(s, m, "Key tree deleted successfully");
+
+ return 0;
+}
+
+int astdb_init(void)
+{
+ dbinit();
+ ast_cli_register_multiple(cli_database, sizeof(cli_database) / sizeof(struct ast_cli_entry));
+ ast_manager_register("DBGet", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, manager_dbget, "Get DB Entry");
+ ast_manager_register("DBPut", EVENT_FLAG_SYSTEM, manager_dbput, "Put DB Entry");
+ ast_manager_register("DBDel", EVENT_FLAG_SYSTEM, manager_dbdel, "Delete DB Entry");
+ ast_manager_register("DBDelTree", EVENT_FLAG_SYSTEM, manager_dbdeltree, "Delete DB Tree");
+ return 0;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-19 00:42:28 +0000