range* rangefunc_get_groups(range_request* rr, range** r)
{
sqlite3* db;
sqlite3_stmt* stmt;
int err;
range* ret = range_new(rr);
apr_pool_t* pool = range_request_pool(rr);
const char** tag_names = range_get_hostnames(pool, r[0]);
const char* tag_name = tag_names[0];
int warn_enabled = range_request_warn_enabled(rr);
if (NULL == tag_name) {
return ret;
}
db = _open_db(rr);
err = sqlite3_prepare(db, GROUPS_SQL, strlen(GROUPS_SQL), &stmt, NULL);
if (err != SQLITE_OK) {
range_request_warn(rr, "?%s: cannot query sqlite db", tag_name );
return ret;
}
assert(err == SQLITE_OK);
sqlite3_bind_text(stmt, 1, tag_name, strlen(tag_name), SQLITE_STATIC);
while(sqlite3_step(stmt) == SQLITE_ROW) {
const char* answer = (const char*)sqlite3_column_text(stmt, 0);
range_add(ret, answer);
}
sqlite3_finalize(stmt);
return ret;
}
range* rangefunc_clusters(range_request* rr, range** r)
{
sqlite3* db;
sqlite3_stmt* stmt;
int err;
range* ret = range_new(rr);
apr_pool_t* pool = range_request_pool(rr);
const char** nodes = range_get_hostnames(pool, r[0]);
const char** p_nodes = nodes;
db = _open_db(rr);
err = sqlite3_prepare(db, CLUSTERS_SQL, strlen(CLUSTERS_SQL), &stmt, NULL);
if (err != SQLITE_OK) {
range_request_warn(rr, "clusters(): cannot query sqlite db");
return ret;
}
while (*p_nodes) {
char * node_name = *p_nodes;
sqlite3_bind_text(stmt, 1, node_name, strlen(node_name), SQLITE_STATIC);
while(sqlite3_step(stmt) == SQLITE_ROW) {
const char* answer = (const char*)sqlite3_column_text(stmt, 0);
range_add(ret, answer);
}
sqlite3_reset(stmt);
sqlite3_clear_bindings(stmt);
++p_nodes;
}
sqlite3_finalize(stmt);
return ret;
}
int
setutxdb(utx_db_t db_type, char *fname)
{
switch (db_type) {
case UTX_DB_UTMPX:
if (fname == NULL)
fname = _PATH_UTMPX;
break;
case UTX_DB_WTMPX:
if (fname == NULL)
fname = _PATH_WTMPX;
break;
default:
errno = EINVAL;
return -1;
}
/* A previous db file is still open */
if (fp != NULL) {
fclose(fp);
fp = NULL;
}
if ((_open_db(fname)) == -1)
return -1;
done:
dbtype = db_type;
return 0;
}
range * rangefunc_group(range_request* rr, range** r)
{
sqlite3* db;
db = _open_db(rr);
range* ret = range_new(rr);
apr_pool_t* pool = range_request_pool(rr);
const char** groups = range_get_hostnames(pool, r[0]);
while (*groups) {
range_union_inplace(rr, ret, _expand_cluster(rr, "GROUPS", *groups));
++groups;
}
return ret;
}
static krb5_error_code
DB_open(krb5_context context, HDB *db, int flags, mode_t mode)
{
DB1_HDB *db1 = (DB1_HDB *)db;
char *fn;
krb5_error_code ret;
asprintf(&fn, "%s.db", db->hdb_name);
if (fn == NULL) {
krb5_set_error_message(context, ENOMEM, "malloc: out of memory");
return ENOMEM;
}
db->hdb_db = _open_db(fn, flags, mode, &db1->lock_fd);
free(fn);
/* try to open without .db extension */
if(db->hdb_db == NULL && errno == ENOENT)
db->hdb_db = _open_db(db->hdb_name, flags, mode, &db1->lock_fd);
if(db->hdb_db == NULL) {
krb5_set_error_message(context, errno, "dbopen (%s): %s",
db->hdb_name, strerror(errno));
return errno;
}
if((flags & O_ACCMODE) == O_RDONLY)
ret = hdb_check_db_format(context, db);
else
ret = hdb_init_db(context, db);
if(ret == HDB_ERR_NOENTRY) {
krb5_clear_error_message(context);
return 0;
}
if (ret) {
DB_close(context, db);
krb5_set_error_message(context, ret, "hdb_open: failed %s database %s",
(flags & O_ACCMODE) == O_RDONLY ?
"checking format of" : "initialize",
db->hdb_name);
}
return ret;
}
range* _do_has_mem(range_request* rr, range** r, char* sql_query)
{
sqlite3* db;
sqlite3_stmt* stmt;
int err;
range* ret = range_new(rr);
apr_pool_t* pool = range_request_pool(rr);
if (NULL == r[0]) {
// don't attempt anything without arg #1 (key)
return ret;
}
const char** tag_names = range_get_hostnames(pool, r[0]);
const char* tag_name = tag_names[0];
if (NULL == tag_name) {
return ret;
}
const char** tag_values;
const char* tag_value;
if (NULL == r[1]) {
// if we don't have arg #2 (val) then search for keys with empty string value
tag_value = EMPTY_STRING;
} else {
tag_values = range_get_hostnames(pool, r[1]);
tag_value = tag_values[0];
}
const char** all_clusters = _all_clusters(rr);
const char** cluster = all_clusters;
int warn_enabled = range_request_warn_enabled(rr);
db = _open_db(rr);
err = sqlite3_prepare(db, sql_query, strlen(sql_query), &stmt,
NULL);
if (err != SQLITE_OK) {
range_request_warn(rr, "has(%s,%s): cannot query sqlite db", tag_name, tag_value);
return ret;
}
assert(err == SQLITE_OK);
sqlite3_bind_text(stmt, 1, tag_name, strlen(tag_name), SQLITE_STATIC);
sqlite3_bind_text(stmt, 2, tag_value, strlen(tag_value), SQLITE_STATIC);
while(sqlite3_step(stmt) == SQLITE_ROW) {
const char* answer = (const char*)sqlite3_column_text(stmt, 0);
range_add(ret, answer);
}
sqlite3_finalize(stmt);
return ret;
}
struct utmpx *
getutxent()
{
if (fp == NULL) {
if ((_open_db(utfile)) == -1)
goto fail;
}
if (fread(&ut, sizeof(ut), 1, fp) != 1)
goto fail;
return &ut;
fail:
(void)memset(&ut, 0, sizeof(ut));
return NULL;
}
static set* _cluster_keys(range_request* rr, apr_pool_t* pool,
const char* cluster)
{
set* sections;
sqlite3* db;
sqlite3_stmt* stmt;
int err;
db = _open_db(rr);
/* our return set */
sections = set_new(pool, 0);
/* prepare our select */
err = sqlite3_prepare(db, KEYVALUE_SQL, strlen(KEYVALUE_SQL),
&stmt, NULL);
if (err != SQLITE_OK) {
range_request_warn(rr, "%s: cannot query sqlite db", cluster);
return sections;
}
assert(err == SQLITE_OK);
/* for each key/value pair in cluster */
sqlite3_bind_text(stmt, 1, cluster, strlen(cluster), SQLITE_STATIC);
while(sqlite3_step(stmt) == SQLITE_ROW) {
/* add it to the return */
const char* key = (const char*)sqlite3_column_text(stmt, 0);
const char* value = (const char*)sqlite3_column_text(stmt, 1);
if (NULL == value) {
value = EMPTY_STRING;
}
set_add(sections, key, apr_psprintf(pool, "%s", _substitute_dollars(pool, cluster, value) ));
}
/* Add the magic "KEYS" index */
set_add(sections, "KEYS", _join_elements(pool, ',', sections));
sqlite3_finalize(stmt);
return sections;
}
