Git does not support the ability to replace a token with a version string during check-in. While it does have support for replacing a token on clone, this is somewhat sub-optimal: the token is replaced with the object hash, which is not particularly easy for human consumption. What's more, in practice, the source file version was often not terribly useful. Generally, when triaging bugs, the overall version of Asterisk is far more useful than an individual SVN version of a file. As a result, this patch removes Asterisk's support for showing source file versions. Specifically, it does the following: * Rename ASTERISK_FILE_VERSION macro to ASTERISK_REGISTER_FILE, and remove passing the version in with the macro. Other facilities than 'core show file version' make use of the file names, such as setting a debug level only on a specific file. As such, the act of registering source files with the Asterisk core still has use. The macro rename now reflects the new macro purpose. * main/asterisk: - Refactor the file_version structure to reflect that it no longer tracks a version field. - Remove the "core show file version" CLI command. Without the file version, it is no longer useful. - Remove the ast_file_version_find function. The file version is no longer tracked. - Rename ast_register_file_version/ast_unregister_file_version to ast_register_file/ast_unregister_file, respectively. * main/manager: Remove value from the Version key of the ModuleCheck Action. The actual key itself has not been removed, as doing so would absolutely constitute a backwards incompatible change. However, since the file version is no longer tracked, there is no need to attempt to include it in the Version key. * UPGRADE: Add notes for: - Modification to the ModuleCheck AMI Action - Removal of the "core show file version" CLI command Change-Id: I6cf0ff280e1668bf4957dc21f32a5ff43444a40e
1034 lines
28 KiB
C
1034 lines
28 KiB
C
/*
|
|
* 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
|
|
*/
|
|
|
|
/*** MODULEINFO
|
|
<support_level>core</support_level>
|
|
***/
|
|
|
|
#include "asterisk.h"
|
|
|
|
ASTERISK_REGISTER_FILE()
|
|
|
|
#include "asterisk/_private.h"
|
|
#include "asterisk/paths.h" /* use ast_config_AST_DB */
|
|
#include <sys/time.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#include <signal.h>
|
|
#include <dirent.h>
|
|
#include <sqlite3.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/manager.h"
|
|
|
|
/*** DOCUMENTATION
|
|
<manager name="DBGet" language="en_US">
|
|
<synopsis>
|
|
Get DB Entry.
|
|
</synopsis>
|
|
<syntax>
|
|
<xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
|
|
<parameter name="Family" required="true" />
|
|
<parameter name="Key" required="true" />
|
|
</syntax>
|
|
<description>
|
|
</description>
|
|
</manager>
|
|
<manager name="DBPut" language="en_US">
|
|
<synopsis>
|
|
Put DB entry.
|
|
</synopsis>
|
|
<syntax>
|
|
<xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
|
|
<parameter name="Family" required="true" />
|
|
<parameter name="Key" required="true" />
|
|
<parameter name="Val" />
|
|
</syntax>
|
|
<description>
|
|
</description>
|
|
</manager>
|
|
<manager name="DBDel" language="en_US">
|
|
<synopsis>
|
|
Delete DB entry.
|
|
</synopsis>
|
|
<syntax>
|
|
<xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
|
|
<parameter name="Family" required="true" />
|
|
<parameter name="Key" required="true" />
|
|
</syntax>
|
|
<description>
|
|
</description>
|
|
</manager>
|
|
<manager name="DBDelTree" language="en_US">
|
|
<synopsis>
|
|
Delete DB Tree.
|
|
</synopsis>
|
|
<syntax>
|
|
<xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
|
|
<parameter name="Family" required="true" />
|
|
<parameter name="Key" />
|
|
</syntax>
|
|
<description>
|
|
</description>
|
|
</manager>
|
|
***/
|
|
|
|
#define MAX_DB_FIELD 256
|
|
AST_MUTEX_DEFINE_STATIC(dblock);
|
|
static ast_cond_t dbcond;
|
|
static sqlite3 *astdb;
|
|
static pthread_t syncthread;
|
|
static int doexit;
|
|
static int dosync;
|
|
|
|
static void db_sync(void);
|
|
|
|
#define DEFINE_SQL_STATEMENT(stmt,sql) static sqlite3_stmt *stmt; \
|
|
const char stmt##_sql[] = sql;
|
|
|
|
DEFINE_SQL_STATEMENT(put_stmt, "INSERT OR REPLACE INTO astdb (key, value) VALUES (?, ?)")
|
|
DEFINE_SQL_STATEMENT(get_stmt, "SELECT value FROM astdb WHERE key=?")
|
|
DEFINE_SQL_STATEMENT(del_stmt, "DELETE FROM astdb WHERE key=?")
|
|
DEFINE_SQL_STATEMENT(deltree_stmt, "DELETE FROM astdb WHERE key || '/' LIKE ? || '/' || '%'")
|
|
DEFINE_SQL_STATEMENT(deltree_all_stmt, "DELETE FROM astdb")
|
|
DEFINE_SQL_STATEMENT(gettree_stmt, "SELECT key, value FROM astdb WHERE key || '/' LIKE ? || '/' || '%' ORDER BY key")
|
|
DEFINE_SQL_STATEMENT(gettree_all_stmt, "SELECT key, value FROM astdb ORDER BY key")
|
|
DEFINE_SQL_STATEMENT(showkey_stmt, "SELECT key, value FROM astdb WHERE key LIKE '%' || '/' || ? ORDER BY key")
|
|
DEFINE_SQL_STATEMENT(create_astdb_stmt, "CREATE TABLE IF NOT EXISTS astdb(key VARCHAR(256), value VARCHAR(256), PRIMARY KEY(key))")
|
|
|
|
static int init_stmt(sqlite3_stmt **stmt, const char *sql, size_t len)
|
|
{
|
|
ast_mutex_lock(&dblock);
|
|
if (sqlite3_prepare(astdb, sql, len, stmt, NULL) != SQLITE_OK) {
|
|
ast_log(LOG_WARNING, "Couldn't prepare statement '%s': %s\n", sql, sqlite3_errmsg(astdb));
|
|
ast_mutex_unlock(&dblock);
|
|
return -1;
|
|
}
|
|
ast_mutex_unlock(&dblock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*! \internal
|
|
* \brief Clean up the prepared SQLite3 statement
|
|
* \note dblock should already be locked prior to calling this method
|
|
*/
|
|
static int clean_stmt(sqlite3_stmt **stmt, const char *sql)
|
|
{
|
|
if (sqlite3_finalize(*stmt) != SQLITE_OK) {
|
|
ast_log(LOG_WARNING, "Couldn't finalize statement '%s': %s\n", sql, sqlite3_errmsg(astdb));
|
|
*stmt = NULL;
|
|
return -1;
|
|
}
|
|
*stmt = NULL;
|
|
return 0;
|
|
}
|
|
|
|
/*! \internal
|
|
* \brief Clean up all prepared SQLite3 statements
|
|
* \note dblock should already be locked prior to calling this method
|
|
*/
|
|
static void clean_statements(void)
|
|
{
|
|
clean_stmt(&get_stmt, get_stmt_sql);
|
|
clean_stmt(&del_stmt, del_stmt_sql);
|
|
clean_stmt(&deltree_stmt, deltree_stmt_sql);
|
|
clean_stmt(&deltree_all_stmt, deltree_all_stmt_sql);
|
|
clean_stmt(&gettree_stmt, gettree_stmt_sql);
|
|
clean_stmt(&gettree_all_stmt, gettree_all_stmt_sql);
|
|
clean_stmt(&showkey_stmt, showkey_stmt_sql);
|
|
clean_stmt(&put_stmt, put_stmt_sql);
|
|
clean_stmt(&create_astdb_stmt, create_astdb_stmt_sql);
|
|
}
|
|
|
|
static int init_statements(void)
|
|
{
|
|
/* Don't initialize create_astdb_statment here as the astdb table needs to exist
|
|
* brefore these statments can be initialized */
|
|
return init_stmt(&get_stmt, get_stmt_sql, sizeof(get_stmt_sql))
|
|
|| init_stmt(&del_stmt, del_stmt_sql, sizeof(del_stmt_sql))
|
|
|| init_stmt(&deltree_stmt, deltree_stmt_sql, sizeof(deltree_stmt_sql))
|
|
|| init_stmt(&deltree_all_stmt, deltree_all_stmt_sql, sizeof(deltree_all_stmt_sql))
|
|
|| init_stmt(&gettree_stmt, gettree_stmt_sql, sizeof(gettree_stmt_sql))
|
|
|| init_stmt(&gettree_all_stmt, gettree_all_stmt_sql, sizeof(gettree_all_stmt_sql))
|
|
|| init_stmt(&showkey_stmt, showkey_stmt_sql, sizeof(showkey_stmt_sql))
|
|
|| init_stmt(&put_stmt, put_stmt_sql, sizeof(put_stmt_sql));
|
|
}
|
|
|
|
static int convert_bdb_to_sqlite3(void)
|
|
{
|
|
char *cmd;
|
|
int res;
|
|
|
|
ast_asprintf(&cmd, "%s/astdb2sqlite3 '%s'\n", ast_config_AST_SBIN_DIR, ast_config_AST_DB);
|
|
res = ast_safe_system(cmd);
|
|
ast_free(cmd);
|
|
|
|
return res;
|
|
}
|
|
|
|
static int db_create_astdb(void)
|
|
{
|
|
int res = 0;
|
|
|
|
if (!create_astdb_stmt) {
|
|
init_stmt(&create_astdb_stmt, create_astdb_stmt_sql, sizeof(create_astdb_stmt_sql));
|
|
}
|
|
|
|
ast_mutex_lock(&dblock);
|
|
if (sqlite3_step(create_astdb_stmt) != SQLITE_DONE) {
|
|
ast_log(LOG_WARNING, "Couldn't create astdb table: %s\n", sqlite3_errmsg(astdb));
|
|
res = -1;
|
|
}
|
|
sqlite3_reset(create_astdb_stmt);
|
|
db_sync();
|
|
ast_mutex_unlock(&dblock);
|
|
|
|
return res;
|
|
}
|
|
|
|
static int db_open(void)
|
|
{
|
|
char *dbname;
|
|
struct stat dont_care;
|
|
|
|
if (!(dbname = ast_alloca(strlen(ast_config_AST_DB) + sizeof(".sqlite3")))) {
|
|
return -1;
|
|
}
|
|
strcpy(dbname, ast_config_AST_DB);
|
|
strcat(dbname, ".sqlite3");
|
|
|
|
if (stat(dbname, &dont_care) && !stat(ast_config_AST_DB, &dont_care)) {
|
|
if (convert_bdb_to_sqlite3()) {
|
|
ast_log(LOG_ERROR, "*** Database conversion failed!\n");
|
|
ast_log(LOG_ERROR, "*** Asterisk now uses SQLite3 for its internal\n");
|
|
ast_log(LOG_ERROR, "*** database. Conversion from the old astdb\n");
|
|
ast_log(LOG_ERROR, "*** failed. Most likely the astdb2sqlite3 utility\n");
|
|
ast_log(LOG_ERROR, "*** was not selected for build. To convert the\n");
|
|
ast_log(LOG_ERROR, "*** old astdb, please delete '%s'\n", dbname);
|
|
ast_log(LOG_ERROR, "*** and re-run 'make menuselect' and select astdb2sqlite3\n");
|
|
ast_log(LOG_ERROR, "*** in the Utilities section, then 'make && make install'.\n");
|
|
ast_log(LOG_ERROR, "*** It is also imperative that the user under which\n");
|
|
ast_log(LOG_ERROR, "*** Asterisk runs have write permission to the directory\n");
|
|
ast_log(LOG_ERROR, "*** where the database resides.\n");
|
|
sleep(5);
|
|
} else {
|
|
ast_log(LOG_NOTICE, "Database conversion succeeded!\n");
|
|
}
|
|
}
|
|
|
|
ast_mutex_lock(&dblock);
|
|
if (sqlite3_open(dbname, &astdb) != SQLITE_OK) {
|
|
ast_log(LOG_WARNING, "Unable to open Asterisk database '%s': %s\n", dbname, sqlite3_errmsg(astdb));
|
|
sqlite3_close(astdb);
|
|
ast_mutex_unlock(&dblock);
|
|
return -1;
|
|
}
|
|
|
|
ast_mutex_unlock(&dblock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int db_init(void)
|
|
{
|
|
if (astdb) {
|
|
return 0;
|
|
}
|
|
|
|
if (db_open() || db_create_astdb() || init_statements()) {
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* We purposely don't lock around the sqlite3 call because the transaction
|
|
* calls will be called with the database lock held. For any other use, make
|
|
* sure to take the dblock yourself. */
|
|
static int db_execute_sql(const char *sql, int (*callback)(void *, int, char **, char **), void *arg)
|
|
{
|
|
char *errmsg = NULL;
|
|
int res =0;
|
|
|
|
if (sqlite3_exec(astdb, sql, callback, arg, &errmsg) != SQLITE_OK) {
|
|
ast_log(LOG_WARNING, "Error executing SQL (%s): %s\n", sql, errmsg);
|
|
sqlite3_free(errmsg);
|
|
res = -1;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
static int ast_db_begin_transaction(void)
|
|
{
|
|
return db_execute_sql("BEGIN TRANSACTION", NULL, NULL);
|
|
}
|
|
|
|
static int ast_db_commit_transaction(void)
|
|
{
|
|
return db_execute_sql("COMMIT", NULL, NULL);
|
|
}
|
|
|
|
static int ast_db_rollback_transaction(void)
|
|
{
|
|
return db_execute_sql("ROLLBACK", NULL, NULL);
|
|
}
|
|
|
|
int ast_db_put(const char *family, const char *key, const char *value)
|
|
{
|
|
char fullkey[MAX_DB_FIELD];
|
|
size_t fullkey_len;
|
|
int res = 0;
|
|
|
|
if (strlen(family) + strlen(key) + 2 > sizeof(fullkey) - 1) {
|
|
ast_log(LOG_WARNING, "Family and key length must be less than %zu bytes\n", sizeof(fullkey) - 3);
|
|
return -1;
|
|
}
|
|
|
|
fullkey_len = snprintf(fullkey, sizeof(fullkey), "/%s/%s", family, key);
|
|
|
|
ast_mutex_lock(&dblock);
|
|
if (sqlite3_bind_text(put_stmt, 1, fullkey, fullkey_len, SQLITE_STATIC) != SQLITE_OK) {
|
|
ast_log(LOG_WARNING, "Couldn't bind key to stmt: %s\n", sqlite3_errmsg(astdb));
|
|
res = -1;
|
|
} else if (sqlite3_bind_text(put_stmt, 2, value, -1, SQLITE_STATIC) != SQLITE_OK) {
|
|
ast_log(LOG_WARNING, "Couldn't bind value to stmt: %s\n", sqlite3_errmsg(astdb));
|
|
res = -1;
|
|
} else if (sqlite3_step(put_stmt) != SQLITE_DONE) {
|
|
ast_log(LOG_WARNING, "Couldn't execute statment: %s\n", sqlite3_errmsg(astdb));
|
|
res = -1;
|
|
}
|
|
|
|
sqlite3_reset(put_stmt);
|
|
db_sync();
|
|
ast_mutex_unlock(&dblock);
|
|
|
|
return res;
|
|
}
|
|
|
|
/*!
|
|
* \internal
|
|
* \brief Get key value specified by family/key.
|
|
*
|
|
* Gets the value associated with the specified \a family and \a key, and
|
|
* stores it, either into the fixed sized buffer specified by \a buffer
|
|
* and \a bufferlen, or as a heap allocated string if \a bufferlen is -1.
|
|
*
|
|
* \note If \a bufferlen is -1, \a buffer points to heap allocated memory
|
|
* and must be freed by calling ast_free().
|
|
*
|
|
* \retval -1 An error occurred
|
|
* \retval 0 Success
|
|
*/
|
|
static int db_get_common(const char *family, const char *key, char **buffer, int bufferlen)
|
|
{
|
|
const unsigned char *result;
|
|
char fullkey[MAX_DB_FIELD];
|
|
size_t fullkey_len;
|
|
int res = 0;
|
|
|
|
if (strlen(family) + strlen(key) + 2 > sizeof(fullkey) - 1) {
|
|
ast_log(LOG_WARNING, "Family and key length must be less than %zu bytes\n", sizeof(fullkey) - 3);
|
|
return -1;
|
|
}
|
|
|
|
fullkey_len = snprintf(fullkey, sizeof(fullkey), "/%s/%s", family, key);
|
|
|
|
ast_mutex_lock(&dblock);
|
|
if (sqlite3_bind_text(get_stmt, 1, fullkey, fullkey_len, SQLITE_STATIC) != SQLITE_OK) {
|
|
ast_log(LOG_WARNING, "Couldn't bind key to stmt: %s\n", sqlite3_errmsg(astdb));
|
|
res = -1;
|
|
} else if (sqlite3_step(get_stmt) != SQLITE_ROW) {
|
|
ast_debug(1, "Unable to find key '%s' in family '%s'\n", key, family);
|
|
res = -1;
|
|
} else if (!(result = sqlite3_column_text(get_stmt, 0))) {
|
|
ast_log(LOG_WARNING, "Couldn't get value\n");
|
|
res = -1;
|
|
} else {
|
|
const char *value = (const char *) result;
|
|
|
|
if (bufferlen == -1) {
|
|
*buffer = ast_strdup(value);
|
|
} else {
|
|
ast_copy_string(*buffer, value, bufferlen);
|
|
}
|
|
}
|
|
sqlite3_reset(get_stmt);
|
|
ast_mutex_unlock(&dblock);
|
|
|
|
return res;
|
|
}
|
|
|
|
int ast_db_get(const char *family, const char *key, char *value, int valuelen)
|
|
{
|
|
ast_assert(value != NULL);
|
|
|
|
/* Make sure we initialize */
|
|
value[0] = 0;
|
|
|
|
return db_get_common(family, key, &value, valuelen);
|
|
}
|
|
|
|
int ast_db_get_allocated(const char *family, const char *key, char **out)
|
|
{
|
|
*out = NULL;
|
|
|
|
return db_get_common(family, key, out, -1);
|
|
}
|
|
|
|
int ast_db_del(const char *family, const char *key)
|
|
{
|
|
char fullkey[MAX_DB_FIELD];
|
|
size_t fullkey_len;
|
|
int res = 0;
|
|
|
|
if (strlen(family) + strlen(key) + 2 > sizeof(fullkey) - 1) {
|
|
ast_log(LOG_WARNING, "Family and key length must be less than %zu bytes\n", sizeof(fullkey) - 3);
|
|
return -1;
|
|
}
|
|
|
|
fullkey_len = snprintf(fullkey, sizeof(fullkey), "/%s/%s", family, key);
|
|
|
|
ast_mutex_lock(&dblock);
|
|
if (sqlite3_bind_text(del_stmt, 1, fullkey, fullkey_len, SQLITE_STATIC) != SQLITE_OK) {
|
|
ast_log(LOG_WARNING, "Couldn't bind key to stmt: %s\n", sqlite3_errmsg(astdb));
|
|
res = -1;
|
|
} else if (sqlite3_step(del_stmt) != SQLITE_DONE) {
|
|
ast_debug(1, "Unable to find key '%s' in family '%s'\n", key, family);
|
|
res = -1;
|
|
}
|
|
sqlite3_reset(del_stmt);
|
|
db_sync();
|
|
ast_mutex_unlock(&dblock);
|
|
|
|
return res;
|
|
}
|
|
|
|
int ast_db_deltree(const char *family, const char *keytree)
|
|
{
|
|
sqlite3_stmt *stmt = deltree_stmt;
|
|
char prefix[MAX_DB_FIELD];
|
|
int res = 0;
|
|
|
|
if (!ast_strlen_zero(family)) {
|
|
if (!ast_strlen_zero(keytree)) {
|
|
/* Family and key tree */
|
|
snprintf(prefix, sizeof(prefix), "/%s/%s", family, keytree);
|
|
} else {
|
|
/* Family only */
|
|
snprintf(prefix, sizeof(prefix), "/%s", family);
|
|
}
|
|
} else {
|
|
prefix[0] = '\0';
|
|
stmt = deltree_all_stmt;
|
|
}
|
|
|
|
ast_mutex_lock(&dblock);
|
|
if (!ast_strlen_zero(prefix) && (sqlite3_bind_text(stmt, 1, prefix, -1, SQLITE_STATIC) != SQLITE_OK)) {
|
|
ast_log(LOG_WARNING, "Could bind %s to stmt: %s\n", prefix, sqlite3_errmsg(astdb));
|
|
res = -1;
|
|
} else if (sqlite3_step(stmt) != SQLITE_DONE) {
|
|
ast_log(LOG_WARNING, "Couldn't execute stmt: %s\n", sqlite3_errmsg(astdb));
|
|
res = -1;
|
|
}
|
|
res = sqlite3_changes(astdb);
|
|
sqlite3_reset(stmt);
|
|
db_sync();
|
|
ast_mutex_unlock(&dblock);
|
|
|
|
return res;
|
|
}
|
|
|
|
struct ast_db_entry *ast_db_gettree(const char *family, const char *keytree)
|
|
{
|
|
char prefix[MAX_DB_FIELD];
|
|
sqlite3_stmt *stmt = gettree_stmt;
|
|
struct ast_db_entry *cur, *last = NULL, *ret = NULL;
|
|
|
|
if (!ast_strlen_zero(family)) {
|
|
if (!ast_strlen_zero(keytree)) {
|
|
/* Family and key tree */
|
|
snprintf(prefix, sizeof(prefix), "/%s/%s", family, keytree);
|
|
} else {
|
|
/* Family only */
|
|
snprintf(prefix, sizeof(prefix), "/%s", family);
|
|
}
|
|
} else {
|
|
prefix[0] = '\0';
|
|
stmt = gettree_all_stmt;
|
|
}
|
|
|
|
ast_mutex_lock(&dblock);
|
|
if (!ast_strlen_zero(prefix) && (sqlite3_bind_text(stmt, 1, prefix, -1, SQLITE_STATIC) != SQLITE_OK)) {
|
|
ast_log(LOG_WARNING, "Could bind %s to stmt: %s\n", prefix, sqlite3_errmsg(astdb));
|
|
sqlite3_reset(stmt);
|
|
ast_mutex_unlock(&dblock);
|
|
return NULL;
|
|
}
|
|
|
|
while (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
const char *key_s, *value_s;
|
|
if (!(key_s = (const char *) sqlite3_column_text(stmt, 0))) {
|
|
break;
|
|
}
|
|
if (!(value_s = (const char *) sqlite3_column_text(stmt, 1))) {
|
|
break;
|
|
}
|
|
if (!(cur = ast_malloc(sizeof(*cur) + strlen(key_s) + strlen(value_s) + 2))) {
|
|
break;
|
|
}
|
|
cur->next = NULL;
|
|
cur->key = cur->data + strlen(value_s) + 1;
|
|
strcpy(cur->data, value_s);
|
|
strcpy(cur->key, key_s);
|
|
if (last) {
|
|
last->next = cur;
|
|
} else {
|
|
ret = cur;
|
|
}
|
|
last = cur;
|
|
}
|
|
sqlite3_reset(stmt);
|
|
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);
|
|
}
|
|
}
|
|
|
|
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[MAX_DB_FIELD];
|
|
|
|
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 num_deleted;
|
|
|
|
switch (cmd) {
|
|
case CLI_INIT:
|
|
e->command = "database deltree";
|
|
e->usage =
|
|
"Usage: database deltree <family> [keytree]\n"
|
|
" OR: database deltree <family>[/keytree]\n"
|
|
" Deletes a family or specific keytree within a family\n"
|
|
" in the Asterisk database. The two arguments may be\n"
|
|
" separated by either a space or a slash.\n";
|
|
return NULL;
|
|
case CLI_GENERATE:
|
|
return NULL;
|
|
}
|
|
|
|
if ((a->argc < 3) || (a->argc > 4))
|
|
return CLI_SHOWUSAGE;
|
|
if (a->argc == 4) {
|
|
num_deleted = ast_db_deltree(a->argv[2], a->argv[3]);
|
|
} else {
|
|
num_deleted = ast_db_deltree(a->argv[2], NULL);
|
|
}
|
|
if (num_deleted < 0) {
|
|
ast_cli(a->fd, "Database unavailable.\n");
|
|
} else if (num_deleted == 0) {
|
|
ast_cli(a->fd, "Database entries do not exist.\n");
|
|
} else {
|
|
ast_cli(a->fd, "%d database entries removed.\n",num_deleted);
|
|
}
|
|
return CLI_SUCCESS;
|
|
}
|
|
|
|
static char *handle_cli_database_show(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
|
{
|
|
char prefix[MAX_DB_FIELD];
|
|
int counter = 0;
|
|
sqlite3_stmt *stmt = gettree_stmt;
|
|
|
|
switch (cmd) {
|
|
case CLI_INIT:
|
|
e->command = "database show";
|
|
e->usage =
|
|
"Usage: database show [family [keytree]]\n"
|
|
" OR: database show [family[/keytree]]\n"
|
|
" Shows Asterisk database contents, optionally restricted\n"
|
|
" to a given family, or family and keytree. The two arguments\n"
|
|
" may be separated either by a space or by a slash.\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';
|
|
stmt = gettree_all_stmt;
|
|
|
|
} else {
|
|
return CLI_SHOWUSAGE;
|
|
}
|
|
|
|
ast_mutex_lock(&dblock);
|
|
if (!ast_strlen_zero(prefix) && (sqlite3_bind_text(stmt, 1, prefix, -1, SQLITE_STATIC) != SQLITE_OK)) {
|
|
ast_log(LOG_WARNING, "Could bind %s to stmt: %s\n", prefix, sqlite3_errmsg(astdb));
|
|
sqlite3_reset(stmt);
|
|
ast_mutex_unlock(&dblock);
|
|
return NULL;
|
|
}
|
|
|
|
while (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
const char *key_s, *value_s;
|
|
if (!(key_s = (const char *) sqlite3_column_text(stmt, 0))) {
|
|
ast_log(LOG_WARNING, "Skipping invalid key!\n");
|
|
continue;
|
|
}
|
|
if (!(value_s = (const char *) sqlite3_column_text(stmt, 1))) {
|
|
ast_log(LOG_WARNING, "Skipping invalid value!\n");
|
|
continue;
|
|
}
|
|
++counter;
|
|
ast_cli(a->fd, "%-50s: %-25s\n", key_s, value_s);
|
|
}
|
|
|
|
sqlite3_reset(stmt);
|
|
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)
|
|
{
|
|
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) {
|
|
return CLI_SHOWUSAGE;
|
|
}
|
|
|
|
ast_mutex_lock(&dblock);
|
|
if (!ast_strlen_zero(a->argv[2]) && (sqlite3_bind_text(showkey_stmt, 1, a->argv[2], -1, SQLITE_STATIC) != SQLITE_OK)) {
|
|
ast_log(LOG_WARNING, "Could bind %s to stmt: %s\n", a->argv[2], sqlite3_errmsg(astdb));
|
|
sqlite3_reset(showkey_stmt);
|
|
ast_mutex_unlock(&dblock);
|
|
return NULL;
|
|
}
|
|
|
|
while (sqlite3_step(showkey_stmt) == SQLITE_ROW) {
|
|
const char *key_s, *value_s;
|
|
if (!(key_s = (const char *) sqlite3_column_text(showkey_stmt, 0))) {
|
|
break;
|
|
}
|
|
if (!(value_s = (const char *) sqlite3_column_text(showkey_stmt, 1))) {
|
|
break;
|
|
}
|
|
++counter;
|
|
ast_cli(a->fd, "%-50s: %-25s\n", key_s, value_s);
|
|
}
|
|
sqlite3_reset(showkey_stmt);
|
|
ast_mutex_unlock(&dblock);
|
|
|
|
ast_cli(a->fd, "%d results found.\n", counter);
|
|
return CLI_SUCCESS;
|
|
}
|
|
|
|
static int display_results(void *arg, int columns, char **values, char **colnames)
|
|
{
|
|
struct ast_cli_args *a = arg;
|
|
size_t x;
|
|
|
|
for (x = 0; x < columns; x++) {
|
|
ast_cli(a->fd, "%-5s: %-50s\n", colnames[x], values[x]);
|
|
}
|
|
ast_cli(a->fd, "\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
static char *handle_cli_database_query(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
|
{
|
|
|
|
switch (cmd) {
|
|
case CLI_INIT:
|
|
e->command = "database query";
|
|
e->usage =
|
|
"Usage: database query \"<SQL Statement>\"\n"
|
|
" Run a user-specified SQL query on the database. Be careful.\n";
|
|
return NULL;
|
|
case CLI_GENERATE:
|
|
return NULL;
|
|
}
|
|
|
|
if (a->argc != 3) {
|
|
return CLI_SHOWUSAGE;
|
|
}
|
|
|
|
ast_mutex_lock(&dblock);
|
|
db_execute_sql(a->argv[2], display_results, a);
|
|
db_sync(); /* Go ahead and sync the db in case they write */
|
|
ast_mutex_unlock(&dblock);
|
|
|
|
return CLI_SUCCESS;
|
|
}
|
|
|
|
static 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"),
|
|
AST_CLI_DEFINE(handle_cli_database_query, "Run a user-specified query on the astdb"),
|
|
};
|
|
|
|
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[MAX_DB_FIELD];
|
|
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;
|
|
}
|
|
|
|
idText[0] = '\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_listack(s, m, "Result will follow", "start");
|
|
|
|
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);
|
|
|
|
astman_send_list_complete_start(s, m, "DBGetComplete", 1);
|
|
astman_send_list_complete_end(s);
|
|
}
|
|
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 num_deleted;
|
|
|
|
if (ast_strlen_zero(family)) {
|
|
astman_send_error(s, m, "No family specified.");
|
|
return 0;
|
|
}
|
|
|
|
if (!ast_strlen_zero(key)) {
|
|
num_deleted = ast_db_deltree(family, key);
|
|
} else {
|
|
num_deleted = ast_db_deltree(family, NULL);
|
|
}
|
|
|
|
if (num_deleted < 0) {
|
|
astman_send_error(s, m, "Database unavailable");
|
|
} else if (num_deleted == 0) {
|
|
astman_send_error(s, m, "Database entry not found");
|
|
} else {
|
|
astman_send_ack(s, m, "Key tree deleted successfully");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*!
|
|
* \internal
|
|
* \brief Signal the astdb sync thread to do its thing.
|
|
*
|
|
* \note dblock is assumed to be held when calling this function.
|
|
*/
|
|
static void db_sync(void)
|
|
{
|
|
dosync = 1;
|
|
ast_cond_signal(&dbcond);
|
|
}
|
|
|
|
/*!
|
|
* \internal
|
|
* \brief astdb sync thread
|
|
*
|
|
* This thread is in charge of syncing astdb to disk after a change.
|
|
* By pushing it off to this thread to take care of, this I/O bound operation
|
|
* will not block other threads from performing other critical processing.
|
|
* If changes happen rapidly, this thread will also ensure that the sync
|
|
* operations are rate limited.
|
|
*/
|
|
static void *db_sync_thread(void *data)
|
|
{
|
|
ast_mutex_lock(&dblock);
|
|
ast_db_begin_transaction();
|
|
for (;;) {
|
|
/* If dosync is set, db_sync() was called during sleep(1),
|
|
* and the pending transaction should be committed.
|
|
* Otherwise, block until db_sync() is called.
|
|
*/
|
|
while (!dosync) {
|
|
ast_cond_wait(&dbcond, &dblock);
|
|
}
|
|
dosync = 0;
|
|
if (ast_db_commit_transaction()) {
|
|
ast_db_rollback_transaction();
|
|
}
|
|
if (doexit) {
|
|
ast_mutex_unlock(&dblock);
|
|
break;
|
|
}
|
|
ast_db_begin_transaction();
|
|
ast_mutex_unlock(&dblock);
|
|
sleep(1);
|
|
ast_mutex_lock(&dblock);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*!
|
|
* \internal
|
|
* \brief Clean up resources on Asterisk shutdown
|
|
*/
|
|
static void astdb_atexit(void)
|
|
{
|
|
ast_cli_unregister_multiple(cli_database, ARRAY_LEN(cli_database));
|
|
ast_manager_unregister("DBGet");
|
|
ast_manager_unregister("DBPut");
|
|
ast_manager_unregister("DBDel");
|
|
ast_manager_unregister("DBDelTree");
|
|
|
|
/* Set doexit to 1 to kill thread. db_sync must be called with
|
|
* mutex held. */
|
|
ast_mutex_lock(&dblock);
|
|
doexit = 1;
|
|
db_sync();
|
|
ast_mutex_unlock(&dblock);
|
|
|
|
pthread_join(syncthread, NULL);
|
|
ast_mutex_lock(&dblock);
|
|
clean_statements();
|
|
if (sqlite3_close(astdb) == SQLITE_OK) {
|
|
astdb = NULL;
|
|
}
|
|
ast_mutex_unlock(&dblock);
|
|
}
|
|
|
|
int astdb_init(void)
|
|
{
|
|
if (db_init()) {
|
|
return -1;
|
|
}
|
|
|
|
ast_cond_init(&dbcond, NULL);
|
|
if (ast_pthread_create_background(&syncthread, NULL, db_sync_thread, NULL)) {
|
|
return -1;
|
|
}
|
|
|
|
ast_register_atexit(astdb_atexit);
|
|
ast_cli_register_multiple(cli_database, ARRAY_LEN(cli_database));
|
|
ast_manager_register_xml_core("DBGet", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, manager_dbget);
|
|
ast_manager_register_xml_core("DBPut", EVENT_FLAG_SYSTEM, manager_dbput);
|
|
ast_manager_register_xml_core("DBDel", EVENT_FLAG_SYSTEM, manager_dbdel);
|
|
ast_manager_register_xml_core("DBDelTree", EVENT_FLAG_SYSTEM, manager_dbdeltree);
|
|
return 0;
|
|
}
|