res_config_pgsql.c File Reference

PostgreSQL plugin for Asterisk RealTime Architecture. More...

#include "asterisk.h"
#include <libpq-fe.h>
#include "asterisk/file.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/config.h"
#include "asterisk/module.h"
#include "asterisk/lock.h"
#include "asterisk/utils.h"
#include "asterisk/cli.h"

Include dependency graph for res_config_pgsql.c:

Go to the source code of this file.

Data Structures
struct	columns
struct	tables::psql_columns
struct	psql_tables
struct	tables

Macros
#define	ESCAPE_CLAUSE   (USE_BACKSLASH_AS_STRING ? " ESCAPE '\\'" : " ESCAPE '\\\\'")
#define	ESCAPE_STRING(buffer, stringname)
#define	has_schema_support   (version > 70300 ? 1 : 0)
#define	IS_SQL_LIKE_CLAUSE(x)   ((x) && ast_ends_with(x, " LIKE"))
#define	MAX_DB_OPTION_SIZE   64
#define	release_table(table)   ast_rwlock_unlock(&(table)->lock);
#define	RES_CONFIG_PGSQL_CONF   "res_pgsql.conf"
#define	USE_BACKSLASH_AS_STRING   (version >= 90100 ? 1 : 0)

Enumerations
enum	{ RQ_WARN , RQ_CREATECLOSE , RQ_CREATECHAR }

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
static int	_pgsql_exec (const char *database, const char *tablename, const char *sql, PGresult **result)
	Helper function for pgsql_exec. For running queries, use pgsql_exec()
struct ast_module *	AST_MODULE_SELF_SYM (void)
	AST_THREADSTORAGE_CUSTOM_SCOPE (escapebuf_buf, NULL, ast_free_ptr, static)
	AST_THREADSTORAGE_CUSTOM_SCOPE (findtable_buf, NULL, ast_free_ptr, static)
	AST_THREADSTORAGE_CUSTOM_SCOPE (semibuf_buf, NULL, ast_free_ptr, static)
	AST_THREADSTORAGE_CUSTOM_SCOPE (sql_buf, NULL, ast_free_ptr, static)
	AST_THREADSTORAGE_CUSTOM_SCOPE (where_buf, NULL, ast_free_ptr, static)
static struct ast_config *	config_pgsql (const char *database, const char *table, const char *file, struct ast_config *cfg, struct ast_flags flags, const char *suggested_incl, const char *who_asked)
static int	destroy_pgsql (const char *database, const char *table, const char *keyfield, const char *lookup, const struct ast_variable *fields)
static void	destroy_table (struct tables *table)
static struct columns *	find_column (struct tables *t, const char *colname)
static struct tables *	find_table (const char *database, const char *orig_tablename)
static char *	handle_cli_realtime_pgsql_cache (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_realtime_pgsql_status (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int	load_module (void)
static int	parse_config (int reload)
static int	pgsql_exec (const char *database, const char *tablename, const char *sql, PGresult **result)
	Do a postgres query, with reconnection support.
static int	pgsql_reconnect (const char *database)
static struct ast_config *	realtime_multi_pgsql (const char *database, const char *table, const struct ast_variable *fields)
static struct ast_variable *	realtime_pgsql (const char *database, const char *tablename, const struct ast_variable *fields)
static int	reload (void)
static int	require_pgsql (const char *database, const char *tablename, va_list ap)
static int	store_pgsql (const char *database, const char *table, const struct ast_variable *fields)
static int	unload_module (void)
static int	unload_pgsql (const char *database, const char *tablename)
static int	update2_pgsql (const char *database, const char *tablename, const struct ast_variable *lookup_fields, const struct ast_variable *update_fields)
static int	update_pgsql (const char *database, const char *tablename, const char *keyfield, const char *lookup, const struct ast_variable *fields)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "PostgreSQL RealTime Configuration Driver" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_EXTENDED, .load = load_module, .unload = unload_module, .reload = reload, .load_pri = AST_MODPRI_REALTIME_DRIVER, .requires = "extconfig", }
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct ast_cli_entry	cli_realtime []
static time_t	connect_time = 0
static char	dbappname [MAX_DB_OPTION_SIZE] = ""
static char	dbhost [MAX_DB_OPTION_SIZE] = ""
static char	dbname [MAX_DB_OPTION_SIZE] = ""
static char	dbpass [MAX_DB_OPTION_SIZE] = ""
static int	dbport = 5432
static char	dbsock [MAX_DB_OPTION_SIZE] = ""
static char	dbuser [MAX_DB_OPTION_SIZE] = ""
static int	order_multi_row_results_by_initial_column = 1
static struct ast_config_engine	pgsql_engine
static ast_mutex_t	pgsql_lock = AST_MUTEX_INIT_VALUE
static PGconn *	pgsqlConn = NULL
static struct psql_tables	psql_tables = AST_LIST_HEAD_INIT_VALUE
static enum { ... }	requirements
static int	version

Detailed Description

PostgreSQL plugin for Asterisk RealTime Architecture.

Author

Mark Spencer marks.nosp@m.ter@.nosp@m.digiu.nosp@m.m.co.nosp@m.m

Manuel Guesdon mgues.nosp@m.don@.nosp@m.oxymi.nosp@m.um.n.nosp@m.et - PostgreSQL RealTime Driver Author/Adaptor

PostgreSQL http://www.postgresql.org

Definition in file res_config_pgsql.c.

Macro Definition Documentation

ESCAPE_CLAUSE

#define ESCAPE_CLAUSE   (USE_BACKSLASH_AS_STRING ? " ESCAPE '\\'" : " ESCAPE '\\\\'")

Definition at line 389 of file res_config_pgsql.c.

ESCAPE_STRING

#define ESCAPE_STRING	(		buffer,
			stringname
	)

Definition at line 99 of file res_config_pgsql.c.

       { \
        int len = strlen(stringname); \
        struct ast_str *semi = ast_str_thread_get(&semibuf_buf, len * 3 + 1); \
        const char *chunk = stringname; \
        ast_str_reset(semi); \
        for (; *chunk; chunk++) { \
            if (strchr(";^", *chunk)) { \
                ast_str_append(&semi, 0, "^%02hhX", *chunk); \
            } else { \
                ast_str_append(&semi, 0, "%c", *chunk); \
            } \
        } \
        if (ast_str_strlen(semi) > (ast_str_size(buffer) - 1) / 2) { \
            ast_str_make_space(&buffer, ast_str_strlen(semi) * 2 + 1); \
        } \
        PQescapeStringConn(pgsqlConn, ast_str_buffer(buffer), ast_str_buffer(semi), ast_str_size(buffer), &pgresult); \
    } while (0)

has_schema_support

#define has_schema_support   (version > 70300 ? 1 : 0)

Definition at line 54 of file res_config_pgsql.c.

IS_SQL_LIKE_CLAUSE

#define IS_SQL_LIKE_CLAUSE

(

x

)

((x) && ast_ends_with(x, " LIKE"))

Definition at line 388 of file res_config_pgsql.c.

MAX_DB_OPTION_SIZE

#define MAX_DB_OPTION_SIZE   64

Definition at line 57 of file res_config_pgsql.c.

release_table

#define release_table

(

table

)

ast_rwlock_unlock(&(table)->lock);

Definition at line 373 of file res_config_pgsql.c.

RES_CONFIG_PGSQL_CONF

#define RES_CONFIG_PGSQL_CONF   "res_pgsql.conf"

Definition at line 50 of file res_config_pgsql.c.

USE_BACKSLASH_AS_STRING

#define USE_BACKSLASH_AS_STRING   (version >= 90100 ? 1 : 0)

Definition at line 55 of file res_config_pgsql.c.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
RQ_WARN
RQ_CREATECLOSE
RQ_CREATECHAR

Definition at line 92 of file res_config_pgsql.c.

{ RQ_WARN, RQ_CREATECLOSE, RQ_CREATECHAR } requirements;

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 1754 of file res_config_pgsql.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 1754 of file res_config_pgsql.c.

_pgsql_exec()

static int _pgsql_exec ( const char *  database, const char *  tablename, const char *  sql, PGresult **  result  )

static

Helper function for pgsql_exec. For running queries, use pgsql_exec()

Connect if not currently connected. Run the given query.

Parameters

database	database name we are connected to (used for error logging)
tablename	table name we are connected to (used for error logging)
sql	sql query string to execute
result	pointer for where to store the result handle

Returns

-1 on fatal query error

-2 on query failure that resulted in disconnection

0 on success

Note

see pgsql_exec for full example

Definition at line 145 of file res_config_pgsql.c.

{
    ExecStatusType result_status;
 
    if (!pgsqlConn) {
        ast_debug(1, "PostgreSQL connection not defined, connecting\n");
 
        if (pgsql_reconnect(database) != 1) {
            ast_log(LOG_NOTICE, "reconnect failed\n");
            *result = NULL;
            return -1;
        }
 
        ast_debug(1, "PostgreSQL connection successful\n");
    }
 
    *result = PQexec(pgsqlConn, sql);
    result_status = PQresultStatus(*result);
    if (result_status != PGRES_COMMAND_OK
        && result_status != PGRES_TUPLES_OK
        && result_status != PGRES_NONFATAL_ERROR) {
 
        ast_log(LOG_ERROR, "PostgreSQL RealTime: Failed to query '%s@%s'.\n", tablename, database);
        ast_log(LOG_ERROR, "PostgreSQL RealTime: Query Failed: %s\n", sql);
        ast_log(LOG_ERROR, "PostgreSQL RealTime: Query Failed because: %s (%s)\n",
            PQresultErrorMessage(*result),
            PQresStatus(result_status));
 
        /* we may have tried to run a command on a disconnected/disconnecting handle */
        /* are we no longer connected to the database... if not try again */
        if (PQstatus(pgsqlConn) != CONNECTION_OK) {
            PQfinish(pgsqlConn);
            pgsqlConn = NULL;
            return -2;
        }
 
        /* connection still okay, which means the query is just plain bad */
        return -1;
    }
 
    ast_debug(1, "PostgreSQL query successful: %s\n", sql);
    return 0;
}

References ast_debug, ast_log, LOG_ERROR, LOG_NOTICE, NULL, pgsql_reconnect(), pgsqlConn, and result.

Referenced by pgsql_exec().

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 1754 of file res_config_pgsql.c.

AST_THREADSTORAGE_CUSTOM_SCOPE() [1/5]

AST_THREADSTORAGE_CUSTOM_SCOPE	(	escapebuf_buf	,
		NULL	,
		ast_free_ptr	,
		static
	)

AST_THREADSTORAGE_CUSTOM_SCOPE() [2/5]

AST_THREADSTORAGE_CUSTOM_SCOPE	(	findtable_buf	,
		NULL	,
		ast_free_ptr	,
		static
	)

AST_THREADSTORAGE_CUSTOM_SCOPE() [3/5]

AST_THREADSTORAGE_CUSTOM_SCOPE	(	semibuf_buf	,
		NULL	,
		ast_free_ptr	,
		static
	)

AST_THREADSTORAGE_CUSTOM_SCOPE() [4/5]

AST_THREADSTORAGE_CUSTOM_SCOPE	(	sql_buf	,
		NULL	,
		ast_free_ptr	,
		static
	)

AST_THREADSTORAGE_CUSTOM_SCOPE() [5/5]

AST_THREADSTORAGE_CUSTOM_SCOPE	(	where_buf	,
		NULL	,
		ast_free_ptr	,
		static
	)

config_pgsql()

static struct ast_config * config_pgsql ( const char *  database, const char *  table, const char *  file, struct ast_config *  cfg, struct ast_flags  flags, const char *  suggested_incl, const char *  who_asked  )

static

Definition at line 1133 of file res_config_pgsql.c.

{
    RAII_VAR(PGresult *, result, NULL, PQclear);
    long num_rows;
    struct ast_variable *new_v;
    struct ast_category *cur_cat = NULL;
    struct ast_str *sql = ast_str_thread_get(&sql_buf, 100);
    char last[80];
    int last_cat_metric = 0;
 
    last[0] = '\0';
 
    /*
     * Ignore database from the extconfig.conf since it is
     * configured by res_pgsql.conf.
     */
    database = dbname;
 
    if (!file || !strcmp(file, RES_CONFIG_PGSQL_CONF)) {
        ast_log(LOG_WARNING, "PostgreSQL RealTime: Cannot configure myself.\n");
        return NULL;
    }
 
    ast_str_set(&sql, 0, "SELECT category, var_name, var_val, cat_metric FROM %s "
            "WHERE filename='%s' and commented=0 "
            "ORDER BY cat_metric DESC, var_metric ASC, category, var_name ", table, file);
 
    ast_debug(1, "PostgreSQL RealTime: Static SQL: %s\n", ast_str_buffer(sql));
 
    ast_mutex_lock(&pgsql_lock);
 
    /* We now have our complete statement; Lets connect to the server and execute it. */
        if (pgsql_exec(database, table, ast_str_buffer(sql), &result) != 0) {
        ast_mutex_unlock(&pgsql_lock);
            return NULL;
        }
 
    if ((num_rows = PQntuples(result)) > 0) {
        int rowIndex = 0;
 
        ast_debug(1, "PostgreSQL RealTime: Found %ld rows.\n", num_rows);
 
        for (rowIndex = 0; rowIndex < num_rows; rowIndex++) {
            char *field_category = PQgetvalue(result, rowIndex, 0);
            char *field_var_name = PQgetvalue(result, rowIndex, 1);
            char *field_var_val = PQgetvalue(result, rowIndex, 2);
            char *field_cat_metric = PQgetvalue(result, rowIndex, 3);
            if (!strcmp(field_var_name, "#include")) {
                if (!ast_config_internal_load(field_var_val, cfg, flags, "", who_asked)) {
                    ast_mutex_unlock(&pgsql_lock);
                    return NULL;
                }
                continue;
            }
 
            if (strcmp(last, field_category) || last_cat_metric != atoi(field_cat_metric)) {
                cur_cat = ast_category_new_dynamic(field_category);
                if (!cur_cat) {
                    break;
                }
                ast_copy_string(last, field_category, sizeof(last));
                last_cat_metric = atoi(field_cat_metric);
                ast_category_append(cfg, cur_cat);
            }
            new_v = ast_variable_new(field_var_name, field_var_val, "");
            ast_variable_append(cur_cat, new_v);
        }
    } else {
        ast_log(LOG_WARNING,
                "PostgreSQL RealTime: Could not find config '%s' in database.\n", file);
    }
 
    ast_mutex_unlock(&pgsql_lock);
 
    return cfg;
}

References ast_category_append(), ast_category_new_dynamic, ast_config_internal_load(), ast_copy_string(), ast_debug, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_str_buffer(), ast_str_set(), ast_str_thread_get(), ast_variable_append(), ast_variable_new, dbname, last, LOG_WARNING, NULL, pgsql_exec(), pgsql_lock, RAII_VAR, RES_CONFIG_PGSQL_CONF, and result.

destroy_pgsql()

static int destroy_pgsql ( const char *  database, const char *  table, const char *  keyfield, const char *  lookup, const struct ast_variable *  fields  )

static

Definition at line 1053 of file res_config_pgsql.c.

{
    RAII_VAR(PGresult *, result, NULL, PQclear);
    int numrows = 0;
    int pgresult;
    struct ast_str *sql = ast_str_thread_get(&sql_buf, 256);
    struct ast_str *buf1 = ast_str_thread_get(&where_buf, 60), *buf2 = ast_str_thread_get(&escapebuf_buf, 60);
    const struct ast_variable *field;
 
    /*
     * Ignore database from the extconfig.conf since it was
     * configured by res_pgsql.conf.
     */
    database = dbname;
 
    if (!table) {
        ast_log(LOG_WARNING, "PostgreSQL RealTime: No table specified.\n");
        return -1;
    }
 
    /*
     * Must connect to the server before anything else as ESCAPE_STRING()
     * uses pgsqlConn
     */
    ast_mutex_lock(&pgsql_lock);
    if (!pgsql_reconnect(database)) {
        ast_mutex_unlock(&pgsql_lock);
        return -1;
    }
 
    /* Get the first parameter and first value in our list of passed paramater/value pairs */
    if (ast_strlen_zero(keyfield) || ast_strlen_zero(lookup))  {
        ast_log(LOG_WARNING,
                "PostgreSQL RealTime: Realtime destroy requires at least 1 parameter and 1 value to search on.\n");
        if (pgsqlConn) {
            PQfinish(pgsqlConn);
            pgsqlConn = NULL;
        }
        ast_mutex_unlock(&pgsql_lock);
        return -1;
    }
 
    /* Create the first part of the query using the first parameter/value pairs we just extracted
       If there is only 1 set, then we have our query. Otherwise, loop thru the list and concat */
 
    ESCAPE_STRING(buf1, keyfield);
    ESCAPE_STRING(buf2, lookup);
    ast_str_set(&sql, 0, "DELETE FROM %s WHERE %s = '%s'", table, ast_str_buffer(buf1), ast_str_buffer(buf2));
    for (field = fields; field; field = field->next) {
        ESCAPE_STRING(buf1, field->name);
        ESCAPE_STRING(buf2, field->value);
        ast_str_append(&sql, 0, " AND %s = '%s'", ast_str_buffer(buf1), ast_str_buffer(buf2));
    }
 
    ast_debug(1, "PostgreSQL RealTime: Delete SQL: %s\n", ast_str_buffer(sql));
 
    /* We now have our complete statement; Lets connect to the server and execute it. */
    if (pgsql_exec(database, table, ast_str_buffer(sql), &result) != 0) {
        ast_mutex_unlock(&pgsql_lock);
        return -1;
    }
 
    numrows = atoi(PQcmdTuples(result));
    ast_mutex_unlock(&pgsql_lock);
 
    ast_debug(1, "PostgreSQL RealTime: Deleted %d rows on table: %s\n", numrows, table);
 
    /* From http://dev.pgsql.com/doc/pgsql/en/pgsql-affected-rows.html
     * An integer greater than zero indicates the number of rows affected
     * Zero indicates that no records were updated
     * -1 indicates that the query returned an error (although, if the query failed, it should have been caught above.)
     */
 
    if (numrows >= 0)
        return (int) numrows;
 
    return -1;
}

References ast_debug, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_str_append(), ast_str_buffer(), ast_str_set(), ast_str_thread_get(), ast_strlen_zero(), dbname, ESCAPE_STRING, LOG_WARNING, ast_variable::name, ast_variable::next, NULL, pgsql_exec(), pgsql_lock, pgsql_reconnect(), pgsqlConn, RAII_VAR, result, and ast_variable::value.

destroy_table()

static void destroy_table ( struct tables *  table )

static

Definition at line 118 of file res_config_pgsql.c.

{
    struct columns *column;
    ast_rwlock_wrlock(&table->lock);
    while ((column = AST_LIST_REMOVE_HEAD(&table->columns, list))) {
        ast_free(column);
    }
    ast_rwlock_unlock(&table->lock);
    ast_rwlock_destroy(&table->lock);
    ast_free(table);
}

References ast_free, AST_LIST_REMOVE_HEAD, ast_rwlock_destroy, ast_rwlock_unlock, ast_rwlock_wrlock, tables::columns, columns::list, and tables::lock.

Referenced by find_table(), unload_module(), and unload_pgsql().

find_column()

static struct columns * find_column ( struct tables *  t, const char *  colname  )

static

Definition at line 375 of file res_config_pgsql.c.

{
    struct columns *column;
 
    /* Check that the column exists in the table */
    AST_LIST_TRAVERSE(&t->columns, column, list) {
        if (strcmp(column->name, colname) == 0) {
            return column;
        }
    }
    return NULL;
}

References AST_LIST_TRAVERSE, tables::columns, columns::list, columns::name, and NULL.

Referenced by update2_pgsql(), and update_pgsql().

find_table()

static struct tables * find_table ( const char *  database, const char *  orig_tablename  )

static

Definition at line 251 of file res_config_pgsql.c.

{
    struct columns *column;
    struct tables *table;
    struct ast_str *sql = ast_str_thread_get(&findtable_buf, 330);
    RAII_VAR(PGresult *, result, NULL, PQclear);
    int exec_result;
    char *fname, *ftype, *flen, *fnotnull, *fdef;
    int i, rows;
 
    AST_LIST_LOCK(&psql_tables);
    AST_LIST_TRAVERSE(&psql_tables, table, list) {
        if (!strcasecmp(table->name, orig_tablename)) {
            ast_debug(1, "Found table in cache; now locking\n");
            ast_rwlock_rdlock(&table->lock);
            ast_debug(1, "Lock cached table; now returning\n");
            AST_LIST_UNLOCK(&psql_tables);
            return table;
        }
    }
 
    if (database == NULL) {
        AST_LIST_UNLOCK(&psql_tables);
        return NULL;
    }
 
    ast_debug(1, "Table '%s' not found in cache, querying now\n", orig_tablename);
 
    /* Not found, scan the table */
    if (has_schema_support) {
        char *schemaname, *tablename, *tmp_schemaname, *tmp_tablename;
        if (strchr(orig_tablename, '.')) {
            tmp_schemaname = ast_strdupa(orig_tablename);
            tmp_tablename = strchr(tmp_schemaname, '.');
            *tmp_tablename++ = '\0';
        } else {
            tmp_schemaname = "";
            tmp_tablename = ast_strdupa(orig_tablename);
        }
 
        tablename = ast_alloca(strlen(tmp_tablename) * 2 + 1);
        PQescapeStringConn(pgsqlConn, tablename, tmp_tablename, strlen(tmp_tablename), NULL);
        schemaname = ast_alloca(strlen(tmp_schemaname) * 2 + 1);
        PQescapeStringConn(pgsqlConn, schemaname, tmp_schemaname, strlen(tmp_schemaname), NULL);
 
        ast_str_set(&sql, 0, "SELECT a.attname, t.typname, a.attlen, a.attnotnull, pg_catalog.pg_get_expr(d.adbin, d.adrelid) adsrc, a.atttypmod FROM (((pg_catalog.pg_class c INNER JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace AND c.relname = '%s' AND n.nspname = %s%s%s) INNER JOIN pg_catalog.pg_attribute a ON (NOT a.attisdropped) AND a.attnum > 0 AND a.attrelid = c.oid) INNER JOIN pg_catalog.pg_type t ON t.oid = a.atttypid) LEFT OUTER JOIN pg_attrdef d ON a.atthasdef AND d.adrelid = a.attrelid AND d.adnum = a.attnum ORDER BY n.nspname, c.relname, attnum",
            tablename,
            ast_strlen_zero(schemaname) ? "" : "'", ast_strlen_zero(schemaname) ? "current_schema()" : schemaname, ast_strlen_zero(schemaname) ? "" : "'");
    } else {
        char *tablename;
        tablename = ast_alloca(strlen(orig_tablename) * 2 + 1);
        PQescapeStringConn(pgsqlConn, tablename, orig_tablename, strlen(orig_tablename), NULL);
 
        ast_str_set(&sql, 0, "SELECT a.attname, t.typname, a.attlen, a.attnotnull, d.adsrc, a.atttypmod FROM pg_class c, pg_type t, pg_attribute a LEFT OUTER JOIN pg_attrdef d ON a.atthasdef AND d.adrelid = a.attrelid AND d.adnum = a.attnum WHERE c.oid = a.attrelid AND a.atttypid = t.oid AND (a.attnum > 0) AND c.relname = '%s' ORDER BY c.relname, attnum", tablename);
    }
 
    ast_mutex_lock(&pgsql_lock);
    exec_result = pgsql_exec(database, orig_tablename, ast_str_buffer(sql), &result);
    ast_mutex_unlock(&pgsql_lock);
    ast_debug(1, "Query of table structure complete.  Now retrieving results.\n");
    if (exec_result != 0) {
        ast_log(LOG_ERROR, "Failed to query database columns for table %s\n", orig_tablename);
        AST_LIST_UNLOCK(&psql_tables);
        return NULL;
    }
 
    if (!(table = ast_calloc(1, sizeof(*table) + strlen(orig_tablename) + 1))) {
        ast_log(LOG_ERROR, "Unable to allocate memory for new table structure\n");
        AST_LIST_UNLOCK(&psql_tables);
        return NULL;
    }
    strcpy(table->name, orig_tablename); /* SAFE */
    ast_rwlock_init(&table->lock);
    AST_LIST_HEAD_INIT_NOLOCK(&table->columns);
 
    rows = PQntuples(result);
    for (i = 0; i < rows; i++) {
        fname = PQgetvalue(result, i, 0);
        ftype = PQgetvalue(result, i, 1);
        flen = PQgetvalue(result, i, 2);
        fnotnull = PQgetvalue(result, i, 3);
        fdef = PQgetvalue(result, i, 4);
        ast_verb(4, "Found column '%s' of type '%s'\n", fname, ftype);
 
        if (!(column = ast_calloc(1, sizeof(*column) + strlen(fname) + strlen(ftype) + 2))) {
            ast_log(LOG_ERROR, "Unable to allocate column element for %s, %s\n", orig_tablename, fname);
            destroy_table(table);
            AST_LIST_UNLOCK(&psql_tables);
            return NULL;
        }
 
        if (strcmp(flen, "-1") == 0) {
            /* Some types, like chars, have the length stored in a different field */
            flen = PQgetvalue(result, i, 5);
            sscanf(flen, "%30d", &column->len);
            column->len -= 4;
        } else {
            sscanf(flen, "%30d", &column->len);
        }
        column->name = (char *)column + sizeof(*column);
        column->type = (char *)column + sizeof(*column) + strlen(fname) + 1;
        strcpy(column->name, fname);
        strcpy(column->type, ftype);
        if (*fnotnull == 't') {
            column->notnull = 1;
        } else {
            column->notnull = 0;
        }
        if (!ast_strlen_zero(fdef)) {
            column->hasdefault = 1;
        } else {
            column->hasdefault = 0;
        }
        AST_LIST_INSERT_TAIL(&table->columns, column, list);
    }
 
    AST_LIST_INSERT_TAIL(&psql_tables, table, list);
    ast_rwlock_rdlock(&table->lock);
    AST_LIST_UNLOCK(&psql_tables);
    return table;
}

References ast_alloca, ast_calloc, ast_debug, AST_LIST_HEAD_INIT_NOLOCK, AST_LIST_INSERT_TAIL, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_rwlock_init, ast_rwlock_rdlock, ast_str_buffer(), ast_str_set(), ast_str_thread_get(), ast_strdupa, ast_strlen_zero(), ast_verb, tables::columns, destroy_table(), has_schema_support, columns::hasdefault, columns::len, tables::lock, LOG_ERROR, columns::name, tables::name, columns::notnull, NULL, pgsql_exec(), pgsql_lock, pgsqlConn, RAII_VAR, result, tables::table, and columns::type.

Referenced by handle_cli_realtime_pgsql_cache(), require_pgsql(), update2_pgsql(), and update_pgsql().

handle_cli_realtime_pgsql_cache()

static char * handle_cli_realtime_pgsql_cache ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 1647 of file res_config_pgsql.c.

{
    struct tables *cur;
    int l, which;
    char *ret = NULL;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "realtime show pgsql cache";
        e->usage =
            "Usage: realtime show pgsql cache [<table>]\n"
            "       Shows table cache for the PostgreSQL RealTime driver\n";
        return NULL;
    case CLI_GENERATE:
        if (a->argc != 4) {
            return NULL;
        }
        l = strlen(a->word);
        which = 0;
        AST_LIST_LOCK(&psql_tables);
        AST_LIST_TRAVERSE(&psql_tables, cur, list) {
            if (!strncasecmp(a->word, cur->name, l) && ++which > a->n) {
                ret = ast_strdup(cur->name);
                break;
            }
        }
        AST_LIST_UNLOCK(&psql_tables);
        return ret;
    }
 
    if (a->argc == 4) {
        /* List of tables */
        AST_LIST_LOCK(&psql_tables);
        AST_LIST_TRAVERSE(&psql_tables, cur, list) {
            ast_cli(a->fd, "%s\n", cur->name);
        }
        AST_LIST_UNLOCK(&psql_tables);
    } else if (a->argc == 5) {
        /* List of columns */
        if ((cur = find_table(NULL, a->argv[4]))) {
            struct columns *col;
            ast_cli(a->fd, "Columns for Table Cache '%s':\n", a->argv[4]);
            ast_cli(a->fd, "%-20.20s %-20.20s %-3.3s %-8.8s\n", "Name", "Type", "Len", "Nullable");
            AST_LIST_TRAVERSE(&cur->columns, col, list) {
                ast_cli(a->fd, "%-20.20s %-20.20s %3d %-8.8s\n", col->name, col->type, col->len, col->notnull ? "NOT NULL" : "");
            }
            release_table(cur);
        } else {
            ast_cli(a->fd, "No such table '%s'\n", a->argv[4]);
        }
    }
    return 0;
}

References a, ast_cli(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_strdup, CLI_GENERATE, CLI_INIT, tables::columns, ast_cli_entry::command, find_table(), columns::len, columns::list, tables::list, columns::name, tables::name, columns::notnull, NULL, release_table, columns::type, and ast_cli_entry::usage.

handle_cli_realtime_pgsql_status()

static char * handle_cli_realtime_pgsql_status ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 1701 of file res_config_pgsql.c.

{
    char connection_info[256];
    char credentials[100] = "";
    char buf[376]; /* 256+100+"Connected to "+" for "+NULL */
    int is_connected = 0, ctimesec = time(NULL) - connect_time;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "realtime show pgsql status";
        e->usage =
            "Usage: realtime show pgsql status\n"
            "       Shows connection information for the PostgreSQL RealTime driver\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != 4)
        return CLI_SHOWUSAGE;
 
    if (!ast_strlen_zero(dbhost))
        snprintf(connection_info, sizeof(connection_info), "%s@%s, port %d", dbname, dbhost, dbport);
    else if (!ast_strlen_zero(dbsock))
        snprintf(connection_info, sizeof(connection_info), "%s on socket file %s", dbname, dbsock);
    else
        snprintf(connection_info, sizeof(connection_info), "%s@%s", dbname, dbhost);
 
    if (!ast_strlen_zero(dbuser))
        snprintf(credentials, sizeof(credentials), " with username %s", dbuser);
 
    ast_mutex_lock(&pgsql_lock);
    is_connected = (pgsqlConn && PQstatus(pgsqlConn) == CONNECTION_OK);
    ast_mutex_unlock(&pgsql_lock);
 
    if (is_connected) {
        snprintf(buf, sizeof(buf), "Connected to %s%s for ", connection_info, credentials);
        ast_cli_print_timestr_fromseconds(a->fd, ctimesec, buf);
        return CLI_SUCCESS;
    } else {
        ast_cli(a->fd, "Unable to connect %s%s\n", connection_info, credentials);
        return CLI_FAILURE;
    }
}

References a, ast_cli(), ast_cli_print_timestr_fromseconds(), ast_mutex_lock, ast_mutex_unlock, ast_strlen_zero(), buf, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, connect_time, dbhost, dbname, dbport, dbsock, dbuser, NULL, pgsql_lock, pgsqlConn, and ast_cli_entry::usage.

load_module()

static int load_module ( void  )

static

Definition at line 1390 of file res_config_pgsql.c.

{
    if(!parse_config(0))
        return AST_MODULE_LOAD_DECLINE;
 
    ast_config_engine_register(&pgsql_engine);
 
    ast_cli_register_multiple(cli_realtime, ARRAY_LEN(cli_realtime));
 
    return 0;
}

References ARRAY_LEN, ast_cli_register_multiple, ast_config_engine_register(), AST_MODULE_LOAD_DECLINE, cli_realtime, parse_config(), and pgsql_engine.

parse_config()

static int parse_config ( int  reload )

static

Definition at line 1435 of file res_config_pgsql.c.

{
    struct ast_config *config;
    const char *s;
    struct ast_flags config_flags = { is_reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
 
    config = ast_config_load(RES_CONFIG_PGSQL_CONF, config_flags);
    if (config == CONFIG_STATUS_FILEUNCHANGED) {
        if (is_reload && pgsqlConn && PQstatus(pgsqlConn) != CONNECTION_OK) {
            ast_log(LOG_WARNING, "PostgreSQL RealTime: Not connected\n");
        }
        return 0;
    }
 
    if (config == CONFIG_STATUS_FILEMISSING || config == CONFIG_STATUS_FILEINVALID) {
        ast_log(LOG_WARNING, "Unable to load config %s\n", RES_CONFIG_PGSQL_CONF);
        return 0;
    }
 
    ast_mutex_lock(&pgsql_lock);
 
    /* XXX: Why would we do this before we're ready to establish a new connection? */
    if (pgsqlConn) {
        PQfinish(pgsqlConn);
        pgsqlConn = NULL;
    }
 
    /* Check new 'user' option first, then fall back to legacy 'dbuser' */
    s = ast_variable_retrieve(config, "general", "user");
    if (!s) {
        s = ast_variable_retrieve(config, "general", "dbuser");
    }
    if (!s) {
        ast_log(LOG_WARNING, "PostgreSQL RealTime: No database user found, using 'asterisk' as default.\n");
        strcpy(dbuser, "asterisk");
    } else {
        ast_copy_string(dbuser, s, sizeof(dbuser));
    }
 
    /* Check new 'password' option first, then fall back to legacy 'dbpass' */
    s = ast_variable_retrieve(config, "general", "password");
    if (!s) {
        s = ast_variable_retrieve(config, "general", "dbpass");
    }
    if (!s) {
        ast_log(LOG_WARNING, "PostgreSQL RealTime: No database password found, using 'asterisk' as default.\n");
        strcpy(dbpass, "asterisk");
    } else {
        ast_copy_string(dbpass, s, sizeof(dbpass));
    }
 
    /* Check new 'hostname' option first, then fall back to legacy 'dbhost' */
    s = ast_variable_retrieve(config, "general", "hostname");
    if (!s) {
        s = ast_variable_retrieve(config, "general", "dbhost");
    }
    if (!s) {
        ast_log(LOG_WARNING, "PostgreSQL RealTime: No database host found, using localhost via socket.\n");
        dbhost[0] = '\0';
    } else {
        ast_copy_string(dbhost, s, sizeof(dbhost));
    }
 
    if (!(s = ast_variable_retrieve(config, "general", "dbname"))) {
        ast_log(LOG_WARNING,
            "PostgreSQL RealTime: No database name found, using 'asterisk' as default.\n");
        strcpy(dbname, "asterisk");
    } else {
        ast_copy_string(dbname, s, sizeof(dbname));
    }
 
    /* Check new 'port' option first, then fall back to legacy 'dbport' */
    s = ast_variable_retrieve(config, "general", "port");
    if (!s) {
        s = ast_variable_retrieve(config, "general", "dbport");
    }
    if (!s) {
        ast_log(LOG_WARNING, "PostgreSQL RealTime: No database port found, using 5432 as default.\n");
        dbport = 5432;
    } else {
        dbport = atoi(s);
    }
 
    /* Check new 'appname' option first, then fall back to legacy 'dbappname' */
    s = ast_variable_retrieve(config, "general", "appname");
    if (!s) {
        s = ast_variable_retrieve(config, "general", "dbappname");
    }
    if (!s) {
        dbappname[0] = '\0';
    } else {
        ast_copy_string(dbappname, s, sizeof(dbappname));
    }
 
    /* Handle socket configuration if no host is specified */
    if (!ast_strlen_zero(dbhost)) {
        /* No socket needed */
    } else {
        s = ast_variable_retrieve(config, "general", "socket");
        if (!s) {
            s = ast_variable_retrieve(config, "general", "dbsock");
        }
        if (!s) {
            ast_log(LOG_WARNING, "PostgreSQL RealTime: No database socket found, using '/tmp/.s.PGSQL.%d' as default.\n", dbport);
            strcpy(dbsock, "/tmp");
        } else {
            ast_copy_string(dbsock, s, sizeof(dbsock));
        }
    }
 
    if (!(s = ast_variable_retrieve(config, "general", "requirements"))) {
        ast_log(LOG_WARNING,
                "PostgreSQL RealTime: no requirements setting found, using 'warn' as default.\n");
        requirements = RQ_WARN;
    } else if (!strcasecmp(s, "createclose")) {
        requirements = RQ_CREATECLOSE;
    } else if (!strcasecmp(s, "createchar")) {
        requirements = RQ_CREATECHAR;
    }
 
    /* Result set ordering is enabled by default */
    s = ast_variable_retrieve(config, "general", "order_multi_row_results_by_initial_column");
    order_multi_row_results_by_initial_column = !s || ast_true(s);
 
    ast_config_destroy(config);
 
    if (DEBUG_ATLEAST(1)) {
        if (!ast_strlen_zero(dbhost)) {
            ast_log(LOG_DEBUG, "PostgreSQL RealTime Host: %s\n", dbhost);
            ast_log(LOG_DEBUG, "PostgreSQL RealTime Port: %i\n", dbport);
        } else {
            ast_log(LOG_DEBUG, "PostgreSQL RealTime Socket: %s\n", dbsock);
        }
        ast_log(LOG_DEBUG, "PostgreSQL RealTime User: %s\n", dbuser);
        ast_log(LOG_DEBUG, "PostgreSQL RealTime Password: %s\n", dbpass);
        ast_log(LOG_DEBUG, "PostgreSQL RealTime DBName: %s\n", dbname);
    }
 
    if (!pgsql_reconnect(NULL)) {
        ast_log(LOG_WARNING,
                "PostgreSQL RealTime: Couldn't establish connection. Check debug.\n");
        ast_debug(1, "PostgreSQL RealTime: Cannot Connect: %s\n", PQerrorMessage(pgsqlConn));
    }
 
    ast_verb(2, "PostgreSQL RealTime reloaded.\n");
 
    /* Done reloading. Release lock so others can now use driver. */
    ast_mutex_unlock(&pgsql_lock);
 
    return 1;
}

References ast_config_destroy(), ast_config_load, ast_copy_string(), ast_debug, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_strlen_zero(), ast_true(), ast_variable_retrieve(), ast_verb, config, CONFIG_FLAG_FILEUNCHANGED, CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEMISSING, CONFIG_STATUS_FILEUNCHANGED, dbappname, dbhost, dbname, dbpass, dbport, dbsock, dbuser, DEBUG_ATLEAST, LOG_DEBUG, LOG_WARNING, NULL, order_multi_row_results_by_initial_column, pgsql_lock, pgsql_reconnect(), pgsqlConn, RES_CONFIG_PGSQL_CONF, RQ_CREATECHAR, RQ_CREATECLOSE, and RQ_WARN.

pgsql_exec()

static int pgsql_exec ( const char *  database, const char *  tablename, const char *  sql, PGresult **  result  )

static

Do a postgres query, with reconnection support.

Connect if not currently connected. Run the given query and if we're disconnected afterwards, reconnect and query again.

Parameters

database	database name we are connected to (used for error logging)
tablename	table name we are connected to (used for error logging)
sql	sql query string to execute
result	pointer for where to store the result handle

Returns

-1 on query failure

0 on success

int i, rows;
PGresult *result;
char *field_name, *field_type, *field_len, *field_notnull, *field_default;
 
pgsql_exec("db", "table", "SELECT 1", &result)
 
rows = PQntuples(result);
for (i = 0; i < rows; i++) {
    field_name    = PQgetvalue(result, i, 0);
    field_type    = PQgetvalue(result, i, 1);
    field_len     = PQgetvalue(result, i, 2);
    field_notnull = PQgetvalue(result, i, 3);
    field_default = PQgetvalue(result, i, 4);
}

Definition at line 219 of file res_config_pgsql.c.

{
    int attempts = 0;
    int res;
 
    /* Try the query, note failure if any */
    /* On first failure, reconnect and try again (_pgsql_exec handles reconnect) */
    /* On second failure, treat as fatal query error */
 
    while (attempts++ < 2) {
        ast_debug(1, "PostgreSQL query attempt %d\n", attempts);
        res = _pgsql_exec(database, tablename, sql, result);
 
        if (res == 0) {
            if (attempts > 1) {
                ast_log(LOG_NOTICE, "PostgreSQL RealTime: Query finally succeeded: %s\n", sql);
            }
 
            return 0;
        }
 
        if (res == -1) {
            return -1; /* Still connected to db, but could not process query (fatal error) */
        }
 
        /* res == -2 (query on a disconnected handle) */
        ast_debug(1, "PostgreSQL query attempt %d failed, trying again\n", attempts);
    }
 
    return -1;
}

References _pgsql_exec(), ast_debug, ast_log, LOG_NOTICE, and result.

Referenced by config_pgsql(), destroy_pgsql(), find_table(), realtime_multi_pgsql(), realtime_pgsql(), require_pgsql(), store_pgsql(), update2_pgsql(), and update_pgsql().

pgsql_reconnect()

static int pgsql_reconnect ( const char *  database )

static

Definition at line 1587 of file res_config_pgsql.c.

{
    char my_database[50];
 
    ast_copy_string(my_database, S_OR(database, dbname), sizeof(my_database));
 
    /* mutex lock should have been locked before calling this function. */
 
    if (pgsqlConn) {
        if (PQstatus(pgsqlConn) == CONNECTION_OK) {
            /* We're good? */
            return 1;
        }
 
        PQfinish(pgsqlConn);
        pgsqlConn = NULL;
    }
 
    /* DB password can legitimately be 0-length */
    if ((!ast_strlen_zero(dbhost) || !ast_strlen_zero(dbsock)) && !ast_strlen_zero(dbuser) && !ast_strlen_zero(my_database)) {
        struct ast_str *conn_info = ast_str_create(128);
 
        if (!conn_info) {
            ast_log(LOG_ERROR, "PostgreSQL RealTime: Failed to allocate memory for connection string.\n");
            return 0;
        }
 
        ast_str_set(&conn_info, 0, "host=%s port=%d dbname=%s user=%s",
            S_OR(dbhost, dbsock), dbport, my_database, dbuser);
 
        if (!ast_strlen_zero(dbappname)) {
            ast_str_append(&conn_info, 0, " application_name=%s", dbappname);
        }
 
        if (!ast_strlen_zero(dbpass)) {
            ast_str_append(&conn_info, 0, " password=%s", dbpass);
        }
 
        pgsqlConn = PQconnectdb(ast_str_buffer(conn_info));
        ast_free(conn_info);
        conn_info = NULL;
 
        ast_debug(1, "pgsqlConn=%p\n", pgsqlConn);
        if (pgsqlConn && PQstatus(pgsqlConn) == CONNECTION_OK) {
            ast_debug(1, "PostgreSQL RealTime: Successfully connected to database.\n");
            connect_time = time(NULL);
            version = PQserverVersion(pgsqlConn);
            return 1;
        } else {
            ast_log(LOG_ERROR,
                    "PostgreSQL RealTime: Failed to connect database %s on %s: %s\n",
                    my_database, dbhost, PQresultErrorMessage(NULL));
            return 0;
        }
    } else {
        ast_debug(1, "PostgreSQL RealTime: One or more of the parameters in the config does not pass our validity checks.\n");
        return 1;
    }
}

References ast_copy_string(), ast_debug, ast_free, ast_log, ast_str_append(), ast_str_buffer(), ast_str_create, ast_str_set(), ast_strlen_zero(), connect_time, dbappname, dbhost, dbname, dbpass, dbport, dbsock, dbuser, LOG_ERROR, NULL, pgsqlConn, S_OR, and version.

realtime_multi_pgsql()

static struct ast_config * realtime_multi_pgsql ( const char *  database, const char *  table, const struct ast_variable *  fields  )

static

Definition at line 525 of file res_config_pgsql.c.

{
    RAII_VAR(PGresult *, result, NULL, PQclear);
    int num_rows = 0, pgresult;
    struct ast_str *sql = ast_str_thread_get(&sql_buf, 100);
    struct ast_str *escapebuf = ast_str_thread_get(&escapebuf_buf, 100);
    const struct ast_variable *field = fields;
    const char *initfield = NULL;
    char *stringp;
    char *chunk;
    char *op;
    char *escape = "";
    struct ast_variable *var = NULL;
    struct ast_config *cfg = NULL;
    struct ast_category *cat = NULL;
 
    /*
     * Ignore database from the extconfig.conf since it was
     * configured by res_pgsql.conf.
     */
    database = dbname;
 
    if (!table) {
        ast_log(LOG_WARNING, "PostgreSQL RealTime: No table specified.\n");
        return NULL;
    }
 
    if (!(cfg = ast_config_new()))
        return NULL;
 
    /*
     * Must connect to the server before anything else as ESCAPE_STRING()
     * uses pgsqlConn
     */
    ast_mutex_lock(&pgsql_lock);
    if (!pgsql_reconnect(database)) {
        ast_mutex_unlock(&pgsql_lock);
        return NULL;
    }
 
    /* Get the first parameter and first value in our list of passed paramater/value pairs */
    if (!field) {
        ast_log(LOG_WARNING,
                "PostgreSQL RealTime: Realtime retrieval requires at least 1 parameter and 1 value to search on.\n");
        if (pgsqlConn) {
            PQfinish(pgsqlConn);
            pgsqlConn = NULL;
        }
        ast_mutex_unlock(&pgsql_lock);
        ast_config_destroy(cfg);
        return NULL;
    }
 
    initfield = ast_strdupa(field->name);
    if ((op = strchr(initfield, ' '))) {
        *op = '\0';
    }
 
    /* Create the first part of the query using the first parameter/value pairs we just extracted
       If there is only 1 set, then we have our query. Otherwise, loop thru the list and concat */
 
    if (!strchr(field->name, ' ')) {
        op = " =";
        escape = "";
    } else {
        op = "";
        if (IS_SQL_LIKE_CLAUSE(field->name)) {
            escape = ESCAPE_CLAUSE;
        }
    }
 
    ESCAPE_STRING(escapebuf, field->value);
    if (pgresult) {
        ast_log(LOG_ERROR, "PostgreSQL RealTime: detected invalid input: '%s'\n", field->value);
        ast_mutex_unlock(&pgsql_lock);
        ast_config_destroy(cfg);
        return NULL;
    }
 
    ast_str_set(&sql, 0, "SELECT * FROM %s WHERE %s%s '%s'%s", table, field->name, op, ast_str_buffer(escapebuf), escape);
    while ((field = field->next)) {
        escape = "";
        if (!strchr(field->name, ' ')) {
            op = " =";
            escape = "";
        } else {
            op = "";
            if (IS_SQL_LIKE_CLAUSE(field->name)) {
                escape = ESCAPE_CLAUSE;
            }
        }
 
        ESCAPE_STRING(escapebuf, field->value);
        if (pgresult) {
            ast_log(LOG_ERROR, "PostgreSQL RealTime: detected invalid input: '%s'\n", field->value);
            ast_mutex_unlock(&pgsql_lock);
            ast_config_destroy(cfg);
            return NULL;
        }
 
        ast_str_append(&sql, 0, " AND %s%s '%s'%s", field->name, op, ast_str_buffer(escapebuf), escape);
    }
 
    if (initfield && order_multi_row_results_by_initial_column) {
        ast_str_append(&sql, 0, " ORDER BY %s", initfield);
    }
 
    /* We now have our complete statement; Lets connect to the server and execute it. */
    if (pgsql_exec(database, table, ast_str_buffer(sql), &result) != 0) {
        ast_mutex_unlock(&pgsql_lock);
        ast_config_destroy(cfg);
        return NULL;
    } else {
        ExecStatusType result_status = PQresultStatus(result);
        if (result_status != PGRES_COMMAND_OK
            && result_status != PGRES_TUPLES_OK
            && result_status != PGRES_NONFATAL_ERROR) {
            ast_log(LOG_WARNING,
                    "PostgreSQL RealTime: Failed to query %s@%s. Check debug for more info.\n", table, database);
            ast_debug(1, "PostgreSQL RealTime: Query: %s\n", ast_str_buffer(sql));
            ast_debug(1, "PostgreSQL RealTime: Query Failed because: %s (%s)\n",
                        PQresultErrorMessage(result), PQresStatus(result_status));
            ast_mutex_unlock(&pgsql_lock);
            ast_config_destroy(cfg);
            return NULL;
        }
    }
 
    ast_debug(1, "PostgreSQL RealTime: Result=%p Query: %s\n", result, ast_str_buffer(sql));
 
    if ((num_rows = PQntuples(result)) > 0) {
        int numFields = PQnfields(result);
        int i = 0;
        int rowIndex = 0;
        char **fieldnames = NULL;
 
        ast_debug(1, "PostgreSQL RealTime: Found %d rows.\n", num_rows);
 
        if (!(fieldnames = ast_calloc(1, numFields * sizeof(char *)))) {
            ast_mutex_unlock(&pgsql_lock);
            ast_config_destroy(cfg);
            return NULL;
        }
        for (i = 0; i < numFields; i++)
            fieldnames[i] = PQfname(result, i);
 
        for (rowIndex = 0; rowIndex < num_rows; rowIndex++) {
            var = NULL;
            cat = ast_category_new_anonymous();
            if (!cat) {
                continue;
            }
            for (i = 0; i < numFields; i++) {
                stringp = PQgetvalue(result, rowIndex, i);
                while (stringp) {
                    chunk = strsep(&stringp, ";");
                    if (chunk && !ast_strlen_zero(ast_realtime_decode_chunk(ast_strip(chunk)))) {
                        if (initfield && !strcmp(initfield, fieldnames[i])) {
                            ast_category_rename(cat, chunk);
                        }
                        var = ast_variable_new(fieldnames[i], chunk, "");
                        ast_variable_append(cat, var);
                    }
                }
            }
            ast_category_append(cfg, cat);
        }
        ast_free(fieldnames);
    } else {
        ast_debug(1, "PostgreSQL RealTime: Could not find any rows in table %s.\n", table);
    }
 
    ast_mutex_unlock(&pgsql_lock);
 
    return cfg;
}

References ast_calloc, ast_category_append(), ast_category_new_anonymous, ast_category_rename(), ast_config_destroy(), ast_config_new(), ast_debug, ast_free, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_realtime_decode_chunk(), ast_str_append(), ast_str_buffer(), ast_str_set(), ast_str_thread_get(), ast_strdupa, ast_strip(), ast_strlen_zero(), ast_variable_append(), ast_variable_new, dbname, ESCAPE_CLAUSE, ESCAPE_STRING, IS_SQL_LIKE_CLAUSE, LOG_ERROR, LOG_WARNING, ast_variable::name, ast_variable::next, NULL, order_multi_row_results_by_initial_column, pgsql_exec(), pgsql_lock, pgsql_reconnect(), pgsqlConn, RAII_VAR, result, strsep(), ast_variable::value, and var.

realtime_pgsql()

static struct ast_variable * realtime_pgsql ( const char *  database, const char *  tablename, const struct ast_variable *  fields  )

static

Definition at line 391 of file res_config_pgsql.c.

{
    RAII_VAR(PGresult *, result, NULL, PQclear);
    int pgresult;
    struct ast_str *sql = ast_str_thread_get(&sql_buf, 100);
    struct ast_str *escapebuf = ast_str_thread_get(&escapebuf_buf, 100);
    char *stringp;
    char *chunk;
    char *op;
    char *escape = "";
    const struct ast_variable *field = fields;
    struct ast_variable *var = NULL, *prev = NULL;
 
    /*
     * Ignore database from the extconfig.conf since it was
     * configured by res_pgsql.conf.
     */
    database = dbname;
 
    if (!tablename) {
        ast_log(LOG_WARNING, "PostgreSQL RealTime: No table specified.\n");
        return NULL;
    }
 
    /*
     * Must connect to the server before anything else as ESCAPE_STRING()
     * uses pgsqlConn
     */
    ast_mutex_lock(&pgsql_lock);
    if (!pgsql_reconnect(database)) {
        ast_mutex_unlock(&pgsql_lock);
        return NULL;
    }
 
    /* Get the first parameter and first value in our list of passed paramater/value pairs */
    if (!field) {
        ast_log(LOG_WARNING,
                "PostgreSQL RealTime: Realtime retrieval requires at least 1 parameter and 1 value to search on.\n");
        if (pgsqlConn) {
            PQfinish(pgsqlConn);
            pgsqlConn = NULL;
        }
        ast_mutex_unlock(&pgsql_lock);
        return NULL;
    }
 
    /* Create the first part of the query using the first parameter/value pairs we just extracted
       If there is only 1 set, then we have our query. Otherwise, loop thru the list and concat */
    if (!strchr(field->name, ' ')) {
        op = " =";
    } else {
        op = "";
        if (IS_SQL_LIKE_CLAUSE(field->name)) {
            escape = ESCAPE_CLAUSE;
        }
    }
 
    ESCAPE_STRING(escapebuf, field->value);
    if (pgresult) {
        ast_log(LOG_ERROR, "PostgreSQL RealTime: detected invalid input: '%s'\n", field->value);
        ast_mutex_unlock(&pgsql_lock);
        return NULL;
    }
 
    ast_str_set(&sql, 0, "SELECT * FROM %s WHERE %s%s '%s'%s", tablename, field->name, op, ast_str_buffer(escapebuf), escape);
    while ((field = field->next)) {
        escape = "";
        if (!strchr(field->name, ' ')) {
            op = " =";
        } else {
            op = "";
            if (IS_SQL_LIKE_CLAUSE(field->name)) {
                escape = ESCAPE_CLAUSE;
            }
        }
 
        ESCAPE_STRING(escapebuf, field->value);
        if (pgresult) {
            ast_log(LOG_ERROR, "PostgreSQL RealTime: detected invalid input: '%s'\n", field->value);
            ast_mutex_unlock(&pgsql_lock);
            return NULL;
        }
 
        ast_str_append(&sql, 0, " AND %s%s '%s'%s", field->name, op, ast_str_buffer(escapebuf), escape);
    }
    ast_str_append(&sql, 0, " LIMIT 1");
 
    /* We now have our complete statement; Lets connect to the server and execute it. */
        if (pgsql_exec(database, tablename, ast_str_buffer(sql), &result) != 0) {
        ast_mutex_unlock(&pgsql_lock);
        return NULL;
        }
 
    ast_debug(1, "PostgreSQL RealTime: Result=%p Query: %s\n", result, ast_str_buffer(sql));
 
    if (PQntuples(result) > 0) {
        int i = 0;
        int numFields = PQnfields(result);
        char **fieldnames = NULL;
 
        ast_debug(1, "PostgreSQL RealTime: Found a row.\n");
 
        if (!(fieldnames = ast_calloc(1, numFields * sizeof(char *)))) {
            ast_mutex_unlock(&pgsql_lock);
            return NULL;
        }
        for (i = 0; i < numFields; i++)
            fieldnames[i] = PQfname(result, i);
        for (i = 0; i < numFields; i++) {
            stringp = PQgetvalue(result, 0, i);
            while (stringp) {
                chunk = strsep(&stringp, ";");
                if (chunk && !ast_strlen_zero(ast_realtime_decode_chunk(ast_strip(chunk)))) {
                    if (prev) {
                        prev->next = ast_variable_new(fieldnames[i], chunk, "");
                        if (prev->next) {
                            prev = prev->next;
                        }
                    } else {
                        prev = var = ast_variable_new(fieldnames[i], chunk, "");
                    }
                }
            }
        }
        ast_free(fieldnames);
    } else {
        ast_debug(1, "Postgresql RealTime: Could not find any rows in table %s@%s.\n", tablename, database);
    }
 
    ast_mutex_unlock(&pgsql_lock);
 
    return var;
}

References ast_calloc, ast_debug, ast_free, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_realtime_decode_chunk(), ast_str_append(), ast_str_buffer(), ast_str_set(), ast_str_thread_get(), ast_strip(), ast_strlen_zero(), ast_variable_new, dbname, ESCAPE_CLAUSE, ESCAPE_STRING, IS_SQL_LIKE_CLAUSE, LOG_ERROR, LOG_WARNING, ast_variable::name, ast_variable::next, NULL, pgsql_exec(), pgsql_lock, pgsql_reconnect(), pgsqlConn, RAII_VAR, result, strsep(), ast_variable::value, and var.

reload()

static int reload ( void  )

static

Definition at line 1428 of file res_config_pgsql.c.

{
    parse_config(1);
 
    return 0;
}

References parse_config().

require_pgsql()

static int require_pgsql ( const char *  database, const char *  tablename, va_list  ap  )

static

Definition at line 1212 of file res_config_pgsql.c.

{
    struct columns *column;
    struct tables *table;
    char *elm;
    int type, res = 0;
    unsigned int size;
 
    /*
     * Ignore database from the extconfig.conf since it was
     * configured by res_pgsql.conf.
     */
    database = dbname;
 
    table = find_table(database, tablename);
    if (!table) {
        ast_log(LOG_WARNING, "Table %s not found in database.  This table should exist if you're using realtime.\n", tablename);
        return -1;
    }
 
    while ((elm = va_arg(ap, char *))) {
        type = va_arg(ap, require_type);
        size = va_arg(ap, unsigned int);
        AST_LIST_TRAVERSE(&table->columns, column, list) {
            if (strcmp(column->name, elm) == 0) {
                /* Char can hold anything, as long as it is large enough */
                if ((strncmp(column->type, "char", 4) == 0 || strncmp(column->type, "varchar", 7) == 0 || strcmp(column->type, "bpchar") == 0 || strncmp(column->type, "text", 4) == 0)) {
                    if (column->len != -1 && (size > column->len)) {
                        ast_log(LOG_WARNING, "Column '%s' should be at least %d long, but is only %d long.\n", column->name, size, column->len);
                        res = -1;
                    }
                } else if (strncmp(column->type, "int", 3) == 0) {
                    int typesize = atoi(column->type + 3);
                    /* Integers can hold only other integers */
                    if ((type == RQ_INTEGER8 || type == RQ_UINTEGER8 ||
                        type == RQ_INTEGER4 || type == RQ_UINTEGER4 ||
                        type == RQ_INTEGER3 || type == RQ_UINTEGER3 ||
                        type == RQ_UINTEGER2) && typesize == 2) {
                        ast_log(LOG_WARNING, "Column '%s' may not be large enough for the required data length: %d\n", column->name, size);
                        res = -1;
                    } else if ((type == RQ_INTEGER8 || type == RQ_UINTEGER8 ||
                        type == RQ_UINTEGER4) && typesize == 4) {
                        ast_log(LOG_WARNING, "Column '%s' may not be large enough for the required data length: %d\n", column->name, size);
                        res = -1;
                    } else if (type == RQ_CHAR || type == RQ_DATETIME || type == RQ_FLOAT || type == RQ_DATE) {
                        ast_log(LOG_WARNING, "Column '%s' is of the incorrect type: (need %s(%d) but saw %s)\n",
                            column->name,
                                type == RQ_CHAR ? "char" :
                                type == RQ_DATETIME ? "datetime" :
                                type == RQ_DATE ? "date" :
                                type == RQ_FLOAT ? "float" :
                                "a rather stiff drink ",
                            size, column->type);
                        res = -1;
                    }
                } else if (strncmp(column->type, "float", 5) == 0) {
                    if (!ast_rq_is_int(type) && type != RQ_FLOAT) {
                        ast_log(LOG_WARNING, "Column %s cannot be a %s\n", column->name, column->type);
                        res = -1;
                    }
                } else if (strncmp(column->type, "timestamp", 9) == 0) {
                    if (type != RQ_DATETIME && type != RQ_DATE) {
                        ast_log(LOG_WARNING, "Column %s cannot be a %s\n", column->name, column->type);
                        res = -1;
                    }
                } else { /* There are other types that no module implements yet */
                    ast_log(LOG_WARNING, "Possibly unsupported column type '%s' on column '%s'\n", column->type, column->name);
                    res = -1;
                }
                break;
            }
        }
 
        if (!column) {
            if (requirements == RQ_WARN) {
                ast_log(LOG_WARNING, "Table %s requires a column '%s' of size '%d', but no such column exists.\n", tablename, elm, size);
                res = -1;
            } else {
                struct ast_str *sql = ast_str_create(100);
                char fieldtype[20];
                PGresult *result;
 
                if (requirements == RQ_CREATECHAR || type == RQ_CHAR) {
                    /* Size is minimum length; make it at least 50% greater,
                     * just to be sure, because PostgreSQL doesn't support
                     * resizing columns. */
                    snprintf(fieldtype, sizeof(fieldtype), "CHAR(%u)",
                        size < 15 ? size * 2 :
                        (size * 3 / 2 > 255) ? 255 : size * 3 / 2);
                } else if (type == RQ_INTEGER1 || type == RQ_UINTEGER1 || type == RQ_INTEGER2) {
                    snprintf(fieldtype, sizeof(fieldtype), "INT2");
                } else if (type == RQ_UINTEGER2 || type == RQ_INTEGER3 || type == RQ_UINTEGER3 || type == RQ_INTEGER4) {
                    snprintf(fieldtype, sizeof(fieldtype), "INT4");
                } else if (type == RQ_UINTEGER4 || type == RQ_INTEGER8) {
                    snprintf(fieldtype, sizeof(fieldtype), "INT8");
                } else if (type == RQ_UINTEGER8) {
                    /* No such type on PostgreSQL */
                    snprintf(fieldtype, sizeof(fieldtype), "CHAR(20)");
                } else if (type == RQ_FLOAT) {
                    snprintf(fieldtype, sizeof(fieldtype), "FLOAT8");
                } else if (type == RQ_DATE) {
                    snprintf(fieldtype, sizeof(fieldtype), "DATE");
                } else if (type == RQ_DATETIME) {
                    snprintf(fieldtype, sizeof(fieldtype), "TIMESTAMP");
                } else {
                    ast_log(LOG_ERROR, "Unrecognized request type %d\n", type);
                    ast_free(sql);
                    continue;
                }
                ast_str_set(&sql, 0, "ALTER TABLE %s ADD COLUMN %s %s", tablename, elm, fieldtype);
                ast_debug(1, "About to lock pgsql_lock (running alter on table '%s' to add column '%s')\n", tablename, elm);
 
                ast_mutex_lock(&pgsql_lock);
                ast_debug(1, "About to run ALTER query on table '%s' to add column '%s'\n", tablename, elm);
 
                    if (pgsql_exec(database, tablename, ast_str_buffer(sql), &result) != 0) {
                    ast_mutex_unlock(&pgsql_lock);
                    release_table(table);
                        return -1;
                    }
 
                ast_debug(1, "Finished running ALTER query on table '%s'\n", tablename);
                if (PQresultStatus(result) != PGRES_COMMAND_OK) {
                    ast_log(LOG_ERROR, "Unable to add column: %s\n", ast_str_buffer(sql));
                }
                PQclear(result);
                ast_mutex_unlock(&pgsql_lock);
 
                ast_free(sql);
            }
        }
    }
    release_table(table);
    return res;
}

References ast_debug, ast_free, AST_LIST_TRAVERSE, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_rq_is_int(), ast_str_buffer(), ast_str_create, ast_str_set(), tables::database, dbname, find_table(), columns::len, tables::list, LOG_ERROR, LOG_WARNING, columns::name, pgsql_exec(), pgsql_lock, release_table, result, RQ_CHAR, RQ_CREATECHAR, RQ_DATE, RQ_DATETIME, RQ_FLOAT, RQ_INTEGER1, RQ_INTEGER2, RQ_INTEGER3, RQ_INTEGER4, RQ_INTEGER8, RQ_UINTEGER1, RQ_UINTEGER2, RQ_UINTEGER3, RQ_UINTEGER4, RQ_UINTEGER8, RQ_WARN, tables::table, type, and columns::type.

store_pgsql()

static int store_pgsql ( const char *  database, const char *  table, const struct ast_variable *  fields  )

static

Definition at line 970 of file res_config_pgsql.c.

{
    RAII_VAR(PGresult *, result, NULL, PQclear);
    int numrows;
    struct ast_str *buf = ast_str_thread_get(&escapebuf_buf, 256);
    struct ast_str *sql1 = ast_str_thread_get(&sql_buf, 256);
    struct ast_str *sql2 = ast_str_thread_get(&where_buf, 256);
    int pgresult;
    const struct ast_variable *field = fields;
 
    /*
     * Ignore database from the extconfig.conf since it was
     * configured by res_pgsql.conf.
     */
    database = dbname;
 
    if (!table) {
        ast_log(LOG_WARNING, "PostgreSQL RealTime: No table specified.\n");
        return -1;
    }
 
    /*
     * Must connect to the server before anything else as ESCAPE_STRING()
     * uses pgsqlConn
     */
    ast_mutex_lock(&pgsql_lock);
    if (!pgsql_reconnect(database)) {
        ast_mutex_unlock(&pgsql_lock);
        return -1;
    }
 
    /* Get the first parameter and first value in our list of passed paramater/value pairs */
    if (!field) {
        ast_log(LOG_WARNING,
                "PostgreSQL RealTime: Realtime storage requires at least 1 parameter and 1 value to store.\n");
        if (pgsqlConn) {
            PQfinish(pgsqlConn);
            pgsqlConn = NULL;
        }
        ast_mutex_unlock(&pgsql_lock);
        return -1;
    }
 
    /* Create the first part of the query using the first parameter/value pairs we just extracted
       If there is only 1 set, then we have our query. Otherwise, loop thru the list and concat */
    ESCAPE_STRING(buf, field->name);
    ast_str_set(&sql1, 0, "INSERT INTO %s (%s", table, ast_str_buffer(buf));
    ESCAPE_STRING(buf, field->value);
    ast_str_set(&sql2, 0, ") VALUES ('%s'", ast_str_buffer(buf));
    while ((field = field->next)) {
        ESCAPE_STRING(buf, field->name);
        ast_str_append(&sql1, 0, ", %s", ast_str_buffer(buf));
        ESCAPE_STRING(buf, field->value);
        ast_str_append(&sql2, 0, ", '%s'", ast_str_buffer(buf));
    }
    ast_str_append(&sql1, 0, "%s)", ast_str_buffer(sql2));
 
    ast_debug(1, "PostgreSQL RealTime: Insert SQL: %s\n", ast_str_buffer(sql1));
 
    /* We now have our complete statement; Lets connect to the server and execute it. */
        if (pgsql_exec(database, table, ast_str_buffer(sql1), &result) != 0) {
        ast_mutex_unlock(&pgsql_lock);
            return -1;
        }
 
    numrows = atoi(PQcmdTuples(result));
    ast_mutex_unlock(&pgsql_lock);
 
    ast_debug(1, "PostgreSQL RealTime: row inserted on table: %s.\n", table);
 
    /* From http://dev.pgsql.com/doc/pgsql/en/pgsql-affected-rows.html
     * An integer greater than zero indicates the number of rows affected
     * Zero indicates that no records were updated
     * -1 indicates that the query returned an error (although, if the query failed, it should have been caught above.)
     */
 
    if (numrows >= 0) {
        return numrows;
    }
 
    return -1;
}

References ast_debug, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_str_append(), ast_str_buffer(), ast_str_set(), ast_str_thread_get(), buf, dbname, ESCAPE_STRING, LOG_WARNING, ast_variable::name, ast_variable::next, NULL, pgsql_exec(), pgsql_lock, pgsql_reconnect(), pgsqlConn, RAII_VAR, result, and ast_variable::value.

unload_module()

static int unload_module ( void  )

static

Definition at line 1402 of file res_config_pgsql.c.

{
    struct tables *table;
    /* Acquire control before doing anything to the module itself. */
    ast_mutex_lock(&pgsql_lock);
 
    if (pgsqlConn) {
        PQfinish(pgsqlConn);
        pgsqlConn = NULL;
    }
    ast_cli_unregister_multiple(cli_realtime, ARRAY_LEN(cli_realtime));
    ast_config_engine_deregister(&pgsql_engine);
 
    /* Unlock so something else can destroy the lock. */
    ast_mutex_unlock(&pgsql_lock);
 
    /* Destroy cached table info */
    AST_LIST_LOCK(&psql_tables);
    while ((table = AST_LIST_REMOVE_HEAD(&psql_tables, list))) {
        destroy_table(table);
    }
    AST_LIST_UNLOCK(&psql_tables);
 
    return 0;
}

References ARRAY_LEN, ast_cli_unregister_multiple(), ast_config_engine_deregister(), AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, ast_mutex_lock, ast_mutex_unlock, cli_realtime, destroy_table(), tables::list, NULL, pgsql_engine, pgsql_lock, pgsqlConn, and tables::table.

unload_pgsql()

static int unload_pgsql ( const char *  database, const char *  tablename  )

static

Definition at line 1348 of file res_config_pgsql.c.

{
    struct tables *cur;
 
    /*
     * Ignore database from the extconfig.conf since it was
     * configured by res_pgsql.conf.
     */
    database = dbname;
 
    ast_debug(2, "About to lock table cache list\n");
    AST_LIST_LOCK(&psql_tables);
    ast_debug(2, "About to traverse table cache list\n");
    AST_LIST_TRAVERSE_SAFE_BEGIN(&psql_tables, cur, list) {
        if (strcmp(cur->name, tablename) == 0) {
            ast_debug(2, "About to remove matching cache entry\n");
            AST_LIST_REMOVE_CURRENT(list);
            ast_debug(2, "About to destroy matching cache entry\n");
            destroy_table(cur);
            ast_debug(1, "Cache entry '%s@%s' destroyed\n", tablename, database);
            break;
        }
    }
    AST_LIST_TRAVERSE_SAFE_END
    AST_LIST_UNLOCK(&psql_tables);
    ast_debug(2, "About to return\n");
    return cur ? 0 : -1;
}

References ast_debug, AST_LIST_LOCK, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_LIST_UNLOCK, tables::database, dbname, destroy_table(), tables::list, and tables::name.

update2_pgsql()

static int update2_pgsql ( const char *  database, const char *  tablename, const struct ast_variable *  lookup_fields, const struct ast_variable *  update_fields  )

static

Definition at line 844 of file res_config_pgsql.c.

{
    RAII_VAR(PGresult *, result, NULL, PQclear);
    int numrows = 0, pgresult, first = 1;
    struct ast_str *escapebuf = ast_str_thread_get(&escapebuf_buf, 16);
    const struct ast_variable *field;
    struct ast_str *sql = ast_str_thread_get(&sql_buf, 100);
    struct ast_str *where = ast_str_thread_get(&where_buf, 100);
    struct tables *table;
 
    /*
     * Ignore database from the extconfig.conf since it was
     * configured by res_pgsql.conf.
     */
    database = dbname;
 
    if (!tablename) {
        ast_log(LOG_WARNING, "PostgreSQL RealTime: No table specified.\n");
        return -1;
    }
 
    if (!escapebuf || !sql || !where) {
        /* Memory error, already handled */
        return -1;
    }
 
    if (!(table = find_table(database, tablename))) {
        ast_log(LOG_ERROR, "Table '%s' does not exist!!\n", tablename);
        return -1;
    }
 
    /*
     * Must connect to the server before anything else as ESCAPE_STRING()
     * uses pgsqlConn
     */
    ast_mutex_lock(&pgsql_lock);
    if (!pgsql_reconnect(database)) {
        ast_mutex_unlock(&pgsql_lock);
        release_table(table);
        return -1;
    }
 
    ast_str_set(&sql, 0, "UPDATE %s SET", tablename);
    ast_str_set(&where, 0, " WHERE");
 
    for (field = lookup_fields; field; field = field->next) {
        if (!find_column(table, field->name)) {
            ast_log(LOG_ERROR, "Attempted to update based on criteria column '%s' (%s@%s), but that column does not exist!\n", field->name, tablename, database);
            ast_mutex_unlock(&pgsql_lock);
            release_table(table);
            return -1;
        }
 
        ESCAPE_STRING(escapebuf, field->value);
        if (pgresult) {
            ast_log(LOG_ERROR, "PostgreSQL RealTime: detected invalid input: '%s'\n", field->value);
            ast_mutex_unlock(&pgsql_lock);
            release_table(table);
            return -1;
        }
        ast_str_append(&where, 0, "%s %s='%s'", first ? "" : " AND", field->name, ast_str_buffer(escapebuf));
        first = 0;
    }
 
    if (first) {
        ast_log(LOG_WARNING,
                "PostgreSQL RealTime: Realtime update requires at least 1 parameter and 1 value to search on.\n");
        if (pgsqlConn) {
            PQfinish(pgsqlConn);
            pgsqlConn = NULL;
        }
        ast_mutex_unlock(&pgsql_lock);
        release_table(table);
        return -1;
    }
 
    /* Now retrieve the columns to update */
    first = 1;
    for (field = update_fields; field; field = field->next) {
        /* If the column is not within the table, then skip it */
        if (!find_column(table, field->name)) {
            ast_log(LOG_NOTICE, "Attempted to update column '%s' in table '%s@%s', but column does not exist!\n", field->name, tablename, database);
            continue;
        }
 
        ESCAPE_STRING(escapebuf, field->value);
        if (pgresult) {
            ast_log(LOG_ERROR, "PostgreSQL RealTime: detected invalid input: '%s'\n", field->value);
            ast_mutex_unlock(&pgsql_lock);
            release_table(table);
            return -1;
        }
 
        ast_str_append(&sql, 0, "%s %s='%s'", first ? "" : ",", field->name, ast_str_buffer(escapebuf));
        first = 0;
    }
    release_table(table);
 
    ast_str_append(&sql, 0, "%s", ast_str_buffer(where));
 
    ast_debug(1, "PostgreSQL RealTime: Update SQL: %s\n", ast_str_buffer(sql));
 
    /* We now have our complete statement; Lets connect to the server and execute it. */
        if (pgsql_exec(database, tablename, ast_str_buffer(sql), &result) != 0) {
        ast_mutex_unlock(&pgsql_lock);
            return -1;
        }
 
    numrows = atoi(PQcmdTuples(result));
    ast_mutex_unlock(&pgsql_lock);
 
    ast_debug(1, "PostgreSQL RealTime: Updated %d rows on table: %s\n", numrows, tablename);
 
    /* From http://dev.pgsql.com/doc/pgsql/en/pgsql-affected-rows.html
     * An integer greater than zero indicates the number of rows affected
     * Zero indicates that no records were updated
     * -1 indicates that the query returned an error (although, if the query failed, it should have been caught above.)
     */
 
    if (numrows >= 0) {
        return (int) numrows;
    }
 
    return -1;
}

References ast_debug, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_str_append(), ast_str_buffer(), ast_str_set(), ast_str_thread_get(), tables::database, dbname, ESCAPE_STRING, find_column(), find_table(), first, LOG_ERROR, LOG_NOTICE, LOG_WARNING, ast_variable::name, ast_variable::next, NULL, pgsql_exec(), pgsql_lock, pgsql_reconnect(), pgsqlConn, RAII_VAR, release_table, result, tables::table, and ast_variable::value.

update_pgsql()

static int update_pgsql ( const char *  database, const char *  tablename, const char *  keyfield, const char *  lookup, const struct ast_variable *  fields  )

static

Definition at line 702 of file res_config_pgsql.c.

{
    RAII_VAR(PGresult *, result, NULL, PQclear);
    int numrows = 0, pgresult;
    const struct ast_variable *field = fields;
    struct ast_str *sql = ast_str_thread_get(&sql_buf, 100);
    struct ast_str *escapebuf = ast_str_thread_get(&escapebuf_buf, 100);
    struct tables *table;
    struct columns *column = NULL;
 
    /*
     * Ignore database from the extconfig.conf since it was
     * configured by res_pgsql.conf.
     */
    database = dbname;
 
    if (!tablename) {
        ast_log(LOG_WARNING, "PostgreSQL RealTime: No table specified.\n");
        return -1;
    }
 
    if (!(table = find_table(database, tablename))) {
        ast_log(LOG_ERROR, "Table '%s' does not exist!!\n", tablename);
        return -1;
    }
 
    /*
     * Must connect to the server before anything else as ESCAPE_STRING()
     * uses pgsqlConn
     */
    ast_mutex_lock(&pgsql_lock);
    if (!pgsql_reconnect(database)) {
        ast_mutex_unlock(&pgsql_lock);
        release_table(table);
        return -1;
    }
 
    /* Get the first parameter and first value in our list of passed paramater/value pairs */
    if (!field) {
        ast_log(LOG_WARNING,
                "PostgreSQL RealTime: Realtime retrieval requires at least 1 parameter and 1 value to search on.\n");
        if (pgsqlConn) {
            PQfinish(pgsqlConn);
            pgsqlConn = NULL;
        }
        ast_mutex_unlock(&pgsql_lock);
        release_table(table);
        return -1;
    }
 
    /* Check that the column exists in the table */
    AST_LIST_TRAVERSE(&table->columns, column, list) {
        if (strcmp(column->name, field->name) == 0) {
            break;
        }
    }
 
    if (!column) {
        ast_log(LOG_ERROR, "PostgreSQL RealTime: Updating on column '%s', but that column does not exist within the table '%s'!\n", field->name, tablename);
        ast_mutex_unlock(&pgsql_lock);
        release_table(table);
        return -1;
    }
 
    /* Create the first part of the query using the first parameter/value pairs we just extracted
       If there is only 1 set, then we have our query. Otherwise, loop thru the list and concat */
 
    ESCAPE_STRING(escapebuf, field->value);
    if (pgresult) {
        ast_log(LOG_ERROR, "PostgreSQL RealTime: detected invalid input: '%s'\n", field->value);
        ast_mutex_unlock(&pgsql_lock);
        release_table(table);
        return -1;
    }
    ast_str_set(&sql, 0, "UPDATE %s SET %s = '%s'", tablename, field->name, ast_str_buffer(escapebuf));
 
    while ((field = field->next)) {
        if (!find_column(table, field->name)) {
            ast_log(LOG_NOTICE, "Attempted to update column '%s' in table '%s', but column does not exist!\n", field->name, tablename);
            continue;
        }
 
        ESCAPE_STRING(escapebuf, field->value);
        if (pgresult) {
            ast_log(LOG_ERROR, "PostgreSQL RealTime: detected invalid input: '%s'\n", field->value);
            ast_mutex_unlock(&pgsql_lock);
            release_table(table);
            return -1;
        }
 
        ast_str_append(&sql, 0, ", %s = '%s'", field->name, ast_str_buffer(escapebuf));
    }
    release_table(table);
 
    ESCAPE_STRING(escapebuf, lookup);
    if (pgresult) {
        ast_log(LOG_ERROR, "PostgreSQL RealTime: detected invalid input: '%s'\n", lookup);
        ast_mutex_unlock(&pgsql_lock);
        return -1;
    }
 
    ast_str_append(&sql, 0, " WHERE %s = '%s'", keyfield, ast_str_buffer(escapebuf));
 
    ast_debug(1, "PostgreSQL RealTime: Update SQL: %s\n", ast_str_buffer(sql));
 
    /* We now have our complete statement; Lets connect to the server and execute it. */
    if (pgsql_exec(database, tablename, ast_str_buffer(sql), &result) != 0) {
        ast_mutex_unlock(&pgsql_lock);
        return -1;
    } else {
        ExecStatusType result_status = PQresultStatus(result);
        if (result_status != PGRES_COMMAND_OK
            && result_status != PGRES_TUPLES_OK
            && result_status != PGRES_NONFATAL_ERROR) {
            ast_log(LOG_WARNING,
                    "PostgreSQL RealTime: Failed to query database. Check debug for more info.\n");
            ast_debug(1, "PostgreSQL RealTime: Query: %s\n", ast_str_buffer(sql));
            ast_debug(1, "PostgreSQL RealTime: Query Failed because: %s (%s)\n",
                        PQresultErrorMessage(result), PQresStatus(result_status));
            ast_mutex_unlock(&pgsql_lock);
            return -1;
        }
    }
 
    numrows = atoi(PQcmdTuples(result));
    ast_mutex_unlock(&pgsql_lock);
 
    ast_debug(1, "PostgreSQL RealTime: Updated %d rows on table: %s\n", numrows, tablename);
 
    /* From http://dev.pgsql.com/doc/pgsql/en/pgsql-affected-rows.html
     * An integer greater than zero indicates the number of rows affected
     * Zero indicates that no records were updated
     * -1 indicates that the query returned an error (although, if the query failed, it should have been caught above.)
     */
 
    if (numrows >= 0)
        return (int) numrows;
 
    return -1;
}

References ast_debug, AST_LIST_TRAVERSE, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_str_append(), ast_str_buffer(), ast_str_set(), ast_str_thread_get(), tables::columns, dbname, ESCAPE_STRING, find_column(), find_table(), columns::list, LOG_ERROR, LOG_NOTICE, LOG_WARNING, columns::name, ast_variable::name, ast_variable::next, NULL, pgsql_exec(), pgsql_lock, pgsql_reconnect(), pgsqlConn, RAII_VAR, release_table, result, tables::table, and ast_variable::value.

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "PostgreSQL RealTime Configuration Driver" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_EXTENDED, .load = load_module, .unload = unload_module, .reload = reload, .load_pri = AST_MODPRI_REALTIME_DRIVER, .requires = "extconfig", }

static

Definition at line 1754 of file res_config_pgsql.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 1754 of file res_config_pgsql.c.

cli_realtime

struct ast_cli_entry cli_realtime[]

static

Initial value:

= {
    { .handler =  handle_cli_realtime_pgsql_status , .summary =  "Shows connection information for the PostgreSQL RealTime driver" ,},
    { .handler =  handle_cli_realtime_pgsql_cache , .summary =  "Shows cached tables within the PostgreSQL realtime driver" ,},
}

Definition at line 94 of file res_config_pgsql.c.

                                             {
    AST_CLI_DEFINE(handle_cli_realtime_pgsql_status, "Shows connection information for the PostgreSQL RealTime driver"),
    AST_CLI_DEFINE(handle_cli_realtime_pgsql_cache, "Shows cached tables within the PostgreSQL realtime driver"),
};

Referenced by load_module(), and unload_module().

connect_time

time_t connect_time = 0

static

Definition at line 84 of file res_config_pgsql.c.

Referenced by handle_cli_realtime_pgsql_status(), and pgsql_reconnect().

dbappname

char dbappname[MAX_DB_OPTION_SIZE] = ""

static

Definition at line 81 of file res_config_pgsql.c.

Referenced by parse_config(), and pgsql_reconnect().

dbhost

char dbhost[MAX_DB_OPTION_SIZE] = ""

static

Definition at line 77 of file res_config_pgsql.c.

Referenced by handle_cli_realtime_pgsql_status(), parse_config(), and pgsql_reconnect().

dbname

char dbname[MAX_DB_OPTION_SIZE] = ""

static

Definition at line 80 of file res_config_pgsql.c.

Referenced by config_pgsql(), db_open(), destroy_pgsql(), handle_cli_realtime_pgsql_status(), parse_config(), pgsql_reconnect(), realtime_multi_pgsql(), realtime_pgsql(), require_pgsql(), store_pgsql(), unload_pgsql(), update2_pgsql(), and update_pgsql().

dbpass

char dbpass[MAX_DB_OPTION_SIZE] = ""

static

Definition at line 79 of file res_config_pgsql.c.

Referenced by parse_config(), and pgsql_reconnect().

dbport

int dbport = 5432

static

Definition at line 83 of file res_config_pgsql.c.

Referenced by handle_cli_realtime_pgsql_status(), parse_config(), and pgsql_reconnect().

dbsock

char dbsock[MAX_DB_OPTION_SIZE] = ""

static

Definition at line 82 of file res_config_pgsql.c.

Referenced by handle_cli_realtime_pgsql_status(), parse_config(), and pgsql_reconnect().

dbuser

char dbuser[MAX_DB_OPTION_SIZE] = ""

static

Definition at line 78 of file res_config_pgsql.c.

Referenced by handle_cli_realtime_pgsql_status(), parse_config(), and pgsql_reconnect().

order_multi_row_results_by_initial_column

int order_multi_row_results_by_initial_column = 1

static

Definition at line 85 of file res_config_pgsql.c.

Referenced by parse_config(), and realtime_multi_pgsql().

pgsql_engine

struct ast_config_engine pgsql_engine

static

Definition at line 1377 of file res_config_pgsql.c.

                                               {
    .name = "pgsql",
    .load_func = config_pgsql,
    .realtime_func = realtime_pgsql,
    .realtime_multi_func = realtime_multi_pgsql,
    .store_func = store_pgsql,
    .destroy_func = destroy_pgsql,
    .update_func = update_pgsql,
    .update2_func = update2_pgsql,
    .require_func = require_pgsql,
    .unload_func = unload_pgsql,
};

Referenced by load_module(), and unload_module().

pgsql_lock

ast_mutex_t pgsql_lock = AST_MUTEX_INIT_VALUE

static

Definition at line 43 of file res_config_pgsql.c.

Referenced by config_pgsql(), destroy_pgsql(), find_table(), handle_cli_realtime_pgsql_status(), parse_config(), realtime_multi_pgsql(), realtime_pgsql(), require_pgsql(), store_pgsql(), unload_module(), update2_pgsql(), and update_pgsql().

pgsqlConn

PGconn* pgsqlConn = NULL

static

Definition at line 52 of file res_config_pgsql.c.

Referenced by _pgsql_exec(), destroy_pgsql(), find_table(), handle_cli_realtime_pgsql_status(), parse_config(), pgsql_reconnect(), realtime_multi_pgsql(), realtime_pgsql(), store_pgsql(), unload_module(), update2_pgsql(), and update_pgsql().

psql_tables

struct psql_tables psql_tables = AST_LIST_HEAD_INIT_VALUE

static

[]

enum { ... } requirements

version

int version

static

Definition at line 53 of file res_config_pgsql.c.

Referenced by pgsql_reconnect().