swd::blacklist_filters swd::database::get_blacklist_filters() {
swd::log::i()->send(swd::notice, "Get blacklist filters from db");
ensure_connection();
boost::unique_lock<boost::mutex> scoped_lock(dbi_mutex_);
dbi_result res = dbi_conn_query(conn_, "SELECT id, impact, rule FROM blacklist_filters");
if (!res) {
throw swd::exceptions::database_exception("Can't execute blacklist_filters query");
}
swd::blacklist_filters filters;
while (dbi_result_next_row(res)) {
swd::blacklist_filter_ptr filter(new swd::blacklist_filter());
filter->set_id(dbi_result_get_uint(res, "id"));
filter->set_impact(dbi_result_get_uint(res, "impact"));
filter->set_regex(dbi_result_get_string(res, "rule"));
filters.push_back(filter);
}
dbi_result_free(res);
return filters;
}
/**
* Go through the database, read and add to the server all
* the registrations stored.
*
* @param c the configuration of the db
* @param s the server
*/
int db_create_registrations(struct config *c, struct server *s)
{
char *q = "SELECT * FROM registrations WHERE server_id = %i;";
struct registration *r;
char *name, *pass;
dbi_result res;
res = dbi_conn_queryf(c->conn, q, s->id);
if (res) {
while (dbi_result_next_row(res)) {
r = new_registration();
r->db_id = dbi_result_get_uint(res, "id");
r->global_flags = dbi_result_get_uint(res, "serveradmin");
name = dbi_result_get_string_copy(res, "name");
strncpy(r->name, name, MIN(29, strlen(name)));
pass = dbi_result_get_string_copy(res, "password");
strcpy(r->password, pass);
add_registration(s, r);
/* free temporary variables */
free(pass); free(name);
}
dbi_result_free(res);
}
return 1;
}
//*******************************************************************
// RETRIEVE PRECEDING RAW RECORD FROM DATABASE (well just the color)
//*******************************************************************
static struct probe_result *get_previous_record(trx *t)
{
dbi_result result;
struct probe_result *prv;
prv = g_malloc0(sizeof(struct probe_result));
if (prv == NULL) {
return(NULL);
}
prv->stattime = t->res->stattime;
prv->color = t->res->color;
if (!t->probe->store_results) return(prv); // we probably don't have a xxxx_raw table
result = db_query(t->probe->db, 0,
"select color, stattime "
"from pr_%s_raw use index(probstat) "
"where probe = '%u' and stattime < '%u' "
"order by stattime desc limit 1",
t->res->name, t->def->probeid, t->res->stattime);
if (!result) return(prv);
if (dbi_result_next_row(result)) {
prv->color = dbi_result_get_uint(result, "color");
prv->stattime = dbi_result_get_uint(result, "stattime");
}
dbi_result_free(result);
t->res->prevcolor = prv->color;
return(prv);
}
void refresh_database(dbi_conn conn)
{
dbi_result result;
char qry[1024];
sprintf(qry, "SELECT pr_pop3_def.id, pr_pop3_def.domid, pr_pop3_def.tblid, pr_realm.name, "
" pr_pop3_def.ipaddress, pr_pop3_def.username, "
" pr_pop3_def.password, "
" pr_pop3_def.yellow, pr_pop3_def.red "
"FROM pr_pop3_def, pr_realm "
"WHERE pr_pop3_def.id > 1 and pr_pop3_def.disable <> 'yes'"
" and pr_pop3_def.pgroup = '%d' and pr_realm.id = pr_pop3_def.domid",
(unsigned)OPT_VALUE_GROUPID);
result = db_query(conn, 1, qry);
if (!result) {
return;
}
while (dbi_result_next_row(result)) {
int id;
struct probedef *probe;
id = dbi_result_get_uint(result, "id");
probe = g_hash_table_lookup(cache, &id);
if (!probe) {
probe = g_malloc0(sizeof(struct probedef));
if (dbi_result_get_uint(result, "domid") > 1) {
probe->probeid = dbi_result_get_uint(result, "tblid");
probe->realm=strdup(dbi_result_get_string(result, "name"));
} else {
probe->probeid = probe->id;
}
g_hash_table_insert(cache, guintdup(id), probe);
}
if (probe->ipaddress) g_free(probe->ipaddress);
probe->ipaddress = dbi_result_get_string_copy(result, "ipaddress");
if (probe->username) g_free(probe->username);
probe->username = dbi_result_get_string_copy(result, "username");
if (probe->password) g_free(probe->password);
probe->password = dbi_result_get_string_copy(result, "password");
probe->yellow = dbi_result_get_float(result, "yellow");
probe->red = dbi_result_get_float(result, "red");
if (probe->msg) g_free(probe->msg);
probe->msg = NULL;
probe->seen = 1;
}
if (dbi_conn_error_flag(conn)) {
const char *errmsg;
dbi_conn_error(conn, &errmsg);
LOG(LOG_ERR, "%s", errmsg);
g_hash_table_foreach(cache, reset_seen, NULL);
} else {
g_hash_table_foreach_remove(cache, return_seen, NULL);
}
dbi_result_free(result);
}
swd::whitelist_rules swd::database::get_whitelist_rules(const int& profile_id,
const std::string& caller, const std::string& path) {
swd::log::i()->send(swd::notice, "Get whitelist rules from db");
ensure_connection();
boost::unique_lock<boost::mutex> scoped_lock(dbi_mutex_);
char *caller_esc = strdup(caller.c_str());
dbi_conn_quote_string(conn_, &caller_esc);
char *path_esc = strdup(path.c_str());
dbi_conn_quote_string(conn_, &path_esc);
/**
* Remove LIKE single character wildcard, because it could result easily in security
* problems if a user forgets to escape an underscore. And instead of a percentage sign
* it is nicer to use an asterisk, because it is more common.
*/
dbi_result res = dbi_conn_queryf(conn_, "SELECT r.id, r.path, f.id as filter_id, "
"f.rule, f.impact, r.min_length, r.max_length FROM whitelist_rules AS r, "
"whitelist_filters AS f WHERE r.filter_id = f.id AND r.profile_id = %i AND %s LIKE "
"prepare_wildcard(r.caller) AND %s LIKE prepare_wildcard(r.path) AND r.status = %i",
profile_id, caller_esc, path_esc, STATUS_ACTIVATED);
free(caller_esc);
free(path_esc);
if (!res) {
throw swd::exceptions::database_exception("Can't execute whitelist_rules query");
}
swd::whitelist_rules rules;
while (dbi_result_next_row(res)) {
swd::whitelist_filter_ptr filter(new swd::whitelist_filter());
filter->set_id(dbi_result_get_uint(res, "filter_id"));
filter->set_regex(dbi_result_get_string(res, "rule"));
swd::whitelist_rule_ptr rule(new swd::whitelist_rule());
rule->set_id(dbi_result_get_uint(res, "id"));
rule->set_filter(filter);
rule->set_min_length(dbi_result_get_uint(res, "min_length"));
rule->set_max_length(dbi_result_get_uint(res, "max_length"));
rules.push_back(rule);
}
dbi_result_free(res);
return rules;
}
swd::profile_ptr swd::database::get_profile(const std::string& server_ip,
const int& profile_id) {
std::stringstream log_message;
log_message << "Get profile from db -> server_ip: " << server_ip
<< "; profile_id: " << profile_id;
swd::log::i()->send(swd::notice, log_message.str());
/* Test the database connection status. Tries to reconnect if disconnected. */
ensure_connection();
/* Mutex to avoid race conditions. */
boost::unique_lock<boost::mutex> scoped_lock(dbi_mutex_);
/**
* First we escape server_ip. It comes from a trusted source, but better safe
* than sorry. This does not work with std::string though.
*/
char *server_ip_esc = strdup(server_ip.c_str());
dbi_conn_quote_string(conn_, &server_ip_esc);
/* Insert the ip and execute the query. */
dbi_result res = dbi_conn_queryf(conn_, "SELECT id, hmac_key, mode, "
"whitelist_enabled, blacklist_enabled, integrity_enabled, flooding_enabled, "
"blacklist_threshold, cache_outdated FROM profiles WHERE %s LIKE "
"prepare_wildcard(server_ip) AND id = %i", server_ip_esc, profile_id);
/* Don't forget to free server_ip_esc to avoid a memory leak. */
free(server_ip_esc);
if (!res) {
throw swd::exceptions::database_exception("Can't execute profile query");
}
if (dbi_result_get_numrows(res) != 1) {
throw swd::exceptions::database_exception("Can't get profile");
}
if (!dbi_result_next_row(res)) {
throw swd::exceptions::database_exception("No profile?");
}
swd::profile_ptr profile(new swd::profile());
profile->set_server_ip(server_ip),
profile->set_id(dbi_result_get_uint(res, "id"));
profile->set_mode(dbi_result_get_uint(res, "mode"));
profile->set_whitelist_enabled(dbi_result_get_uint(res, "whitelist_enabled") == 1);
profile->set_blacklist_enabled(dbi_result_get_uint(res, "blacklist_enabled") == 1);
profile->set_integrity_enabled(dbi_result_get_uint(res, "integrity_enabled") == 1);
profile->set_flooding_enabled(dbi_result_get_uint(res, "flooding_enabled") == 1);
profile->set_key(dbi_result_get_string(res, "hmac_key"));
profile->set_blacklist_threshold(dbi_result_get_uint(res, "blacklist_threshold"));
profile->set_cache_outdated(dbi_result_get_uint(res, "cache_outdated") == 1);
dbi_result_free(res);
return profile;
}
bool swd::database::is_flooding(const std::string& client_ip,
const int& profile_id) {
ensure_connection();
boost::unique_lock<boost::mutex> scoped_lock(dbi_mutex_);
char *client_ip_esc = strdup(client_ip.c_str());
dbi_conn_quote_string(conn_, &client_ip_esc);
dbi_result res = dbi_conn_queryf(conn_, "SELECT is_flooding(%i, %s) AS result",
profile_id, client_ip_esc);
free(client_ip_esc);
if (!res) {
throw swd::exceptions::database_exception("Can't execute request count query");
}
bool flooding = false;
if (dbi_result_get_numrows(res) == 1) {
if (!dbi_result_next_row(res)) {
throw swd::exceptions::database_exception("No flooding?");
}
flooding = (dbi_result_get_uint(res, "result") == 1);
}
dbi_result_free(res);
return flooding;
}
//*******************************************************************
// UPDATE SERVER COLOR
//*******************************************************************
static void update_server_color(trx *t, struct probe_result *prv)
{
dbi_result result;
int maxcolor, newcolor;
if (t->def->server < 2) return;
if (t->probe->fuse && (t->res->color < prv->color)) {
// if this probe acts like a fuse, use the previous color if it's higher
newcolor = prv->color;
} else {
newcolor = t->res->color;
}
maxcolor = newcolor; // init
result = db_query(t->probe->db, 0,
"select max(color) as color from pr_status where server = '%u'", t->def->server);
if (result && dbi_result_next_row(result)) {
maxcolor = dbi_result_get_uint(result, "color");
}
dbi_result_free(result);
//if (t->res->color <= maxcolor) return;
result = db_query(t->probe->db, 0,
// update server set color = '200' where id = '345'
"update %s set %s = '%u' where %s = '%u'",
OPT_ARG(SERVER_TABLE_NAME), OPT_ARG(SERVER_TABLE_COLOR_FIELD),
maxcolor, OPT_ARG(SERVER_TABLE_ID_FIELD), t->def->server);
dbi_result_free(result);
}
int find_expired_probes(struct dbspec *dbspec)
{
xmlDocPtr doc;
xmlNodePtr probe;
dbi_result result;
dbi_conn conn;
int count = 0;
char buf[10];
sprintf(buf, "%d", dbspec->port);
conn = open_database(OPT_ARG(DBTYPE), dbspec->host, buf, dbspec->db,
dbspec->user, dbspec->password);
if (!conn) return 0;
doc = UpwatchXmlDoc("result", NULL);
// find all expired probes, but skip those for which processing
// has been stopped for some reason
result = db_query(conn, 0, "select probe.name, pr_status.probe, "
" pr_status.server, pr_status.color, "
" pr_status.expires "
"from pr_status, probe "
"where probe.id = pr_status.class and color <> 400 "
" and expires < UNIX_TIMESTAMP()-30 "
" and expires < probe.lastseen"
" and probe.expiry = 'yes'");
if (!result) goto errexit;
while (dbi_result_next_row(result)) {
char buffer[256];
time_t now = time(NULL);
probe = xmlNewChild(xmlDocGetRootElement(doc), NULL, dbi_result_get_string(result, "name"), NULL);
xmlSetProp(probe, "realm", dbspec->realm);
xmlSetProp(probe, "id", dbi_result_get_string(result, "probe"));
xmlSetProp(probe, "server", dbi_result_get_string(result, "server"));
sprintf(buffer, "%u", (int) now); xmlSetProp(probe, "date", buffer);
xmlSetProp(probe, "expires", dbi_result_get_string(result, "expires"));
xmlNewChild(probe, NULL, "color", "400"); // PURPLE
xmlNewChild(probe, NULL, "prevcolor", dbi_result_get_string(result, "color"));
LOG(LOG_INFO, "%s: purpled %s %d", dbspec->realm, dbi_result_get_string(result, "name"),
dbi_result_get_uint(result, "probe"));
count++;
}
if (count) {
xmlSetDocCompressMode(doc, OPT_VALUE_COMPRESS);
spool_result(OPT_ARG(SPOOLDIR), OPT_ARG(OUTPUT), doc, NULL);
LOG(LOG_INFO, "%s: purpled %u probes", dbspec->realm, count);
}
errexit:
if (result) dbi_result_free(result);
if (conn) close_database(conn);
if (doc) xmlFreeDoc(doc);
return count;
}
swd::blacklist_rules swd::database::get_blacklist_rules(const int& profile_id,
const std::string& caller, const std::string& path) {
swd::log::i()->send(swd::notice, "Get blacklist rules from db");
ensure_connection();
boost::unique_lock<boost::mutex> scoped_lock(dbi_mutex_);
char *caller_esc = strdup(caller.c_str());
dbi_conn_quote_string(conn_, &caller_esc);
char *path_esc = strdup(path.c_str());
dbi_conn_quote_string(conn_, &path_esc);
dbi_result res = dbi_conn_queryf(conn_, "SELECT r.id, r.path, r.threshold "
"FROM blacklist_rules AS r WHERE r.profile_id = %i AND %s LIKE "
"prepare_wildcard(r.caller) AND %s LIKE prepare_wildcard(r.path) AND "
"r.status = %i", profile_id, caller_esc, path_esc, STATUS_ACTIVATED);
free(caller_esc);
free(path_esc);
if (!res) {
throw swd::exceptions::database_exception("Can't execute blacklist_rules query");
}
swd::blacklist_rules rules;
while (dbi_result_next_row(res)) {
swd::blacklist_rule_ptr rule(new swd::blacklist_rule());
rule->set_id(dbi_result_get_uint(res, "id"));
rule->set_threshold(dbi_result_get_uint(res, "threshold"));
rules.push_back(rule);
}
dbi_result_free(res);
return rules;
}
//*******************************************************************
// SEE IF THE USER HAS BEEN NOTIFIED FOR THIS COLOR
//*******************************************************************
void get_previous_pr_hist(trx *t)
{
dbi_result result;
t->res->changed = 0;
strcpy(t->res->notified, "yes"); // if we cannot find pr_hist record, assume the user has already been warned
result = db_query(t->probe->db, 0,
"select id, stattime, notified, prv_color "
"from pr_hist "
"where probe = '%u' and class = '%u' and stattime <= '%u' "
"order by stattime desc limit 1",
t->def->probeid, t->probe->class, t->res->stattime);
if (!result) return;
if (dbi_result_next_row(result)) {
t->res->prevhistid = dbi_result_get_longlong(t->probe->db, "id");
t->res->changed = dbi_result_get_uint(t->probe->db, "stattime");
strcpy(t->res->notified, dbi_result_get_string(t->probe->db, "notified"));
t->res->prevhistcolor = dbi_result_get_uint(t->probe->db, "prv_color");
}
dbi_result_free(result);
return;
}
//************************************************************************
// read pr_status file for expired probes. Construct fake results
// for those.
//***********************************************************************
int run(void)
{
dbi_result result;
dbi_conn conn;
int count = 0;
conn = open_database(OPT_ARG(DBTYPE), OPT_ARG(DBHOST), OPT_ARG(DBPORT), OPT_ARG(DBNAME),
OPT_ARG(DBUSER), OPT_ARG(DBPASSWD));
if (!conn) return 0;
LOG(LOG_INFO, "processing ..");
uw_setproctitle("reading info from database");
result = db_query(conn, 0, "select pr_realm.id, pr_realm.name, pr_realm.host, "
" pr_realm.port, pr_realm.db, pr_realm.user, "
" pr_realm.password "
"from pr_realm "
"where pr_realm.id > 1");
if (result) {
while (dbi_result_next_row(result)) {
struct dbspec db;
db.domid = dbi_result_get_uint(result, "id");
db.realm = dbi_result_get_string(result, "name");
db.host = dbi_result_get_string(result, "host");
db.port = dbi_result_get_uint(result, "port");
db.db = dbi_result_get_string(result, "db");
db.user = dbi_result_get_string(result, "user");
db.password = dbi_result_get_string(result, "password");
uw_setproctitle("checking %s", dbi_result_get_string(result, "name"));
LOG(LOG_DEBUG, "checking %s", dbi_result_get_string(result, "name"));
count += find_expired_probes(&db);
}
dbi_result_free(result);
}
close_database(conn);
LOG(LOG_INFO, "sleeping");
return count;
}
//*******************************************************************
// RETRIEVE FOLLOWING RAW RECORD FROM DATABASE (well just the color)
//*******************************************************************
static struct probe_result *get_following_record(trx *t)
{
dbi_result result;
struct probe_result *nxt = NULL;
if (!t->probe->store_results) return(NULL); // we probably don't have a xxxx_raw table
result = db_query(t->probe->db, 0,
"select color, stattime "
"from pr_%s_raw use index(probstat) "
"where probe = '%u' and stattime > '%u' "
"order by stattime asc limit 1",
t->res->name, t->def->probeid, t->res->stattime);
if (result) {
if (dbi_result_next_row(result)) {
nxt = g_malloc0(sizeof(struct probe_result));
nxt->color = dbi_result_get_uint(result, "color");
nxt->stattime = dbi_result_get_uint(result, "stattime");
}
dbi_result_free(result);
}
return(nxt);
}
void db_create_pl_ch_privileges(struct config *c, struct server *s)
{
dbi_result res;
int flags;
size_t iter, iter2;
int reg_id;
struct channel *ch;
struct registration *reg;
struct player_channel_privilege *tmp_priv;
char *q = "SELECT * FROM player_channel_privileges WHERE channel_id = %i;";
logger(LOG_INFO, "Reading player channel privileges...");
ar_each(struct channel *, ch, iter, s->chans)
if (!(ch->flags & CHANNEL_FLAG_UNREGISTERED)) {
res = dbi_conn_queryf(c->conn, q, ch->db_id);
if (res) {
while (dbi_result_next_row(res)) {
tmp_priv = new_player_channel_privilege();
tmp_priv->ch = ch;
flags = 0;
if (dbi_result_get_uint(res, "channel_admin"))
flags |= CHANNEL_PRIV_CHANADMIN;
if (dbi_result_get_uint(res, "operator"))
flags |= CHANNEL_PRIV_OP;
if (dbi_result_get_uint(res, "voice"))
flags |= CHANNEL_PRIV_VOICE;
if (dbi_result_get_uint(res, "auto_operator"))
flags |= CHANNEL_PRIV_AUTOOP;
if (dbi_result_get_uint(res, "auto_voice"))
flags |= CHANNEL_PRIV_AUTOVOICE;
tmp_priv->flags = flags;
tmp_priv->reg = PL_CH_PRIV_REGISTERED;
reg_id = dbi_result_get_uint(res, "player_id");
ar_each(struct registration *, reg, iter2, s->regs)
if (reg->db_id == reg_id)
tmp_priv->pl_or_reg.reg = reg;
ar_end_each;
if (tmp_priv->pl_or_reg.reg != NULL)
add_player_channel_privilege(ch, tmp_priv);
else
free(tmp_priv);
}
dbi_result_free(res);
} else {
//*******************************************************************
// IS THIS SLOT COMPLETELY FILLED?
//*******************************************************************
int slot_is_complete(trx *t, int i, guint slotlow, guint slothigh)
{
dbi_result result;
int val = FALSE;
/*
* don't know how many raw records go into a day slot,
* so we fake it is filled, so it'll always be summarized
*/
if (i == 0) return 1;
result = db_query(t->probe->db, 0,
"select count(*) as count from pr_%s_%s use index(probstat) "
"where probe = '%u' and stattime >= '%u' and stattime <= '%u'",
t->res->name, summ_info[i].from, t->def->probeid, slotlow, slothigh);
if (!result) return(FALSE);
if (dbi_result_next_row(result)) {
if (dbi_result_get_uint(result, "count") >= summ_info[i].perslot) {
val = TRUE;
}
}
dbi_result_free(result);
return(val);
}
swd::integrity_rules swd::database::get_integrity_rules(const int& profile_id,
const std::string& caller) {
swd::log::i()->send(swd::notice, "Get integrity rules from db");
ensure_connection();
boost::unique_lock<boost::mutex> scoped_lock(dbi_mutex_);
char *caller_esc = strdup(caller.c_str());
dbi_conn_quote_string(conn_, &caller_esc);
dbi_result res = dbi_conn_queryf(conn_, "SELECT r.id, r.algorithm, r.digest FROM "
"integrity_rules AS r WHERE r.profile_id = %i AND %s LIKE prepare_wildcard(r.caller) "
"AND r.status = %i", profile_id, caller_esc, STATUS_ACTIVATED);
free(caller_esc);
if (!res) {
throw swd::exceptions::database_exception("Can't execute whitelist_rules query");
}
swd::integrity_rules rules;
while (dbi_result_next_row(res)) {
swd::integrity_rule_ptr rule(new swd::integrity_rule());
rule->set_id(dbi_result_get_uint(res, "id"));
rule->set_algorithm(dbi_result_get_string(res, "algorithm"));
rule->set_digest(dbi_result_get_string(res, "digest"));
rules.push_back(rule);
}
dbi_result_free(res);
return rules;
}
/**
* Go through the database, read and add to the server all
* the server permissions stored.
*
* @param c the configuration of the db
* @param s the server
*/
int db_create_sv_privileges(struct config *c, struct server *s)
{
char *q = "SELECT * FROM server_privileges WHERE server_id = %i;";
dbi_result res;
const char *group;
int g;
struct server_privileges *sp = s->privileges;
logger(LOG_INFO, "Loading server privileges.");
res = dbi_conn_queryf(c->conn, q, s->id);
if (res) {
while (dbi_result_next_row(res)) {
/* Get the id of the group from the string */
group = dbi_result_get_string(res, "user_group");
if (strcmp(group, "server_admin") == 0) {
g = PRIV_SERVER_ADMIN;
} else if (strcmp(group, "channel_admin") == 0) {
g = PRIV_CHANNEL_ADMIN;
} else if (strcmp(group, "operator") == 0) {
g = PRIV_OPERATOR;
} else if (strcmp(group, "voice") == 0) {
g = PRIV_VOICE;
} else if (strcmp(group, "registered") == 0) {
g = PRIV_REGISTERED;
} else if (strcmp(group, "anonymous") == 0) {
g = PRIV_ANONYMOUS;
} else {
logger(LOG_ERR, "server_privileges.user_group = %s, \
expected : server_admin, channel_admin, \
operator, voice, registered, anonymous.",
group);
continue;
}
logger(LOG_DBG, "GROUP : %i", g);
/* Copy all privileges to the server... */
sp->priv[g][SP_ADM_DEL_SERVER] = dbi_result_get_uint(res, "adm_del_server");
sp->priv[g][SP_ADM_ADD_SERVER] = dbi_result_get_uint(res, "adm_add_server");
sp->priv[g][SP_ADM_LIST_SERVERS] = dbi_result_get_uint(res, "adm_list_servers");
sp->priv[g][SP_ADM_SET_PERMISSIONS] = dbi_result_get_uint(res, "adm_set_permissions");
sp->priv[g][SP_ADM_CHANGE_USER_PASS] = dbi_result_get_uint(res, "adm_change_user_pass");
sp->priv[g][SP_ADM_CHANGE_OWN_PASS] = dbi_result_get_uint(res, "adm_change_own_pass");
sp->priv[g][SP_ADM_LIST_REGISTRATIONS] = dbi_result_get_uint(res, "adm_list_registrations");
sp->priv[g][SP_ADM_REGISTER_PLAYER] = dbi_result_get_uint(res, "adm_register_player");
sp->priv[g][SP_ADM_CHANGE_SERVER_CODECS] = dbi_result_get_uint(res, "adm_change_server_codecs");
sp->priv[g][SP_ADM_CHANGE_SERVER_TYPE] = dbi_result_get_uint(res, "adm_change_server_type");
sp->priv[g][SP_ADM_CHANGE_SERVER_PASS] = dbi_result_get_uint(res, "adm_change_server_pass");
sp->priv[g][SP_ADM_CHANGE_SERVER_WELCOME] = dbi_result_get_uint(res, "adm_change_server_welcome");
sp->priv[g][SP_ADM_CHANGE_SERVER_MAXUSERS] = dbi_result_get_uint(res, "adm_change_server_maxusers");
sp->priv[g][SP_ADM_CHANGE_SERVER_NAME] = dbi_result_get_uint(res, "adm_change_server_name");
sp->priv[g][SP_ADM_CHANGE_WEBPOST_URL] = dbi_result_get_uint(res, "adm_change_webpost_url");
sp->priv[g][SP_ADM_CHANGE_SERVER_PORT] = dbi_result_get_uint(res, "adm_change_server_port");
sp->priv[g][SP_ADM_START_SERVER] = dbi_result_get_uint(res, "adm_start_server");
sp->priv[g][SP_ADM_STOP_SERVER] = dbi_result_get_uint(res, "adm_stop_server");
sp->priv[g][SP_ADM_MOVE_PLAYER] = dbi_result_get_uint(res, "adm_move_player");
sp->priv[g][SP_ADM_BAN_IP] = dbi_result_get_uint(res, "adm_ban_ip");
sp->priv[g][SP_CHA_DELETE] = dbi_result_get_uint(res, "cha_delete");
sp->priv[g][SP_CHA_CREATE_MODERATED] = dbi_result_get_uint(res, "cha_create_moderated");
sp->priv[g][SP_CHA_CREATE_SUBCHANNELED] = dbi_result_get_uint(res, "cha_create_subchanneled");
sp->priv[g][SP_CHA_CREATE_DEFAULT] = dbi_result_get_uint(res, "cha_create_default");
sp->priv[g][SP_CHA_CREATE_UNREGISTERED] = dbi_result_get_uint(res, "cha_create_unregistered");
sp->priv[g][SP_CHA_CREATE_REGISTERED] = dbi_result_get_uint(res, "cha_create_registered");
sp->priv[g][SP_CHA_JOIN_REGISTERED] = dbi_result_get_uint(res, "cha_join_registered");
sp->priv[g][SP_CHA_JOIN_WO_PASS] = dbi_result_get_uint(res, "cha_join_wo_pass");
sp->priv[g][SP_CHA_CHANGE_CODEC] = dbi_result_get_uint(res, "cha_change_codec");
sp->priv[g][SP_CHA_CHANGE_MAXUSERS] = dbi_result_get_uint(res, "cha_change_maxusers");
sp->priv[g][SP_CHA_CHANGE_ORDER] = dbi_result_get_uint(res, "cha_change_order");
sp->priv[g][SP_CHA_CHANGE_DESC] = dbi_result_get_uint(res, "cha_change_desc");
sp->priv[g][SP_CHA_CHANGE_TOPIC] = dbi_result_get_uint(res, "cha_change_topic");
sp->priv[g][SP_CHA_CHANGE_PASS] = dbi_result_get_uint(res, "cha_change_pass");
sp->priv[g][SP_CHA_CHANGE_NAME] = dbi_result_get_uint(res, "cha_change_name");
sp->priv[g][SP_PL_GRANT_ALLOWREG] = dbi_result_get_uint(res, "pl_grant_allowreg");
sp->priv[g][SP_PL_GRANT_VOICE] = dbi_result_get_uint(res, "pl_grant_voice");
sp->priv[g][SP_PL_GRANT_AUTOVOICE] = dbi_result_get_uint(res, "pl_grant_autovoice");
sp->priv[g][SP_PL_GRANT_OP] = dbi_result_get_uint(res, "pl_grant_op");
sp->priv[g][SP_PL_GRANT_AUTOOP] = dbi_result_get_uint(res, "pl_grant_autoop");
sp->priv[g][SP_PL_GRANT_CA] = dbi_result_get_uint(res, "pl_grant_ca");
sp->priv[g][SP_PL_GRANT_SA] = dbi_result_get_uint(res, "pl_grant_sa");
sp->priv[g][SP_PL_REGISTER_PLAYER] = dbi_result_get_uint(res, "pl_register_player");
sp->priv[g][SP_PL_REVOKE_ALLOWREG] = dbi_result_get_uint(res, "pl_revoke_allowreg");
sp->priv[g][SP_PL_REVOKE_VOICE] = dbi_result_get_uint(res, "pl_revoke_voice");
sp->priv[g][SP_PL_REVOKE_AUTOVOICE] = dbi_result_get_uint(res, "pl_revoke_autovoice");
sp->priv[g][SP_PL_REVOKE_OP] = dbi_result_get_uint(res, "pl_revoke_op");
sp->priv[g][SP_PL_REVOKE_AUTOOP] = dbi_result_get_uint(res, "pl_revoke_autoop");
sp->priv[g][SP_PL_REVOKE_CA] = dbi_result_get_uint(res, "pl_revoke_ca");
sp->priv[g][SP_PL_REVOKE_SA] = dbi_result_get_uint(res, "pl_revoke_sa");
sp->priv[g][SP_PL_ALLOW_SELF_REG] = dbi_result_get_uint(res, "pl_allow_self_reg");
sp->priv[g][SP_PL_DEL_REGISTRATION] = dbi_result_get_uint(res, "pl_del_registration");
sp->priv[g][SP_OTHER_CH_COMMANDER] = dbi_result_get_uint(res, "other_ch_commander");
sp->priv[g][SP_OTHER_CH_KICK] = dbi_result_get_uint(res, "other_ch_kick");
sp->priv[g][SP_OTHER_SV_KICK] = dbi_result_get_uint(res, "other_sv_kick");
sp->priv[g][SP_OTHER_TEXT_PL] = dbi_result_get_uint(res, "other_text_pl");
sp->priv[g][SP_OTHER_TEXT_ALL_CH] = dbi_result_get_uint(res, "other_text_all_ch");
sp->priv[g][SP_OTHER_TEXT_IN_CH] = dbi_result_get_uint(res, "other_text_in_ch");
sp->priv[g][SP_OTHER_TEXT_ALL] = dbi_result_get_uint(res, "other_text_all");
}
dbi_result_free(res);
}
return 1;
}
static void _bind_helper_uint(_field_binding_t *binding) {
*(unsigned int *)binding->bindto = dbi_result_get_uint((dbi_result)binding->result, binding->fieldname);
}
unsigned int dbi_result_get_fields(dbi_result Result, const char *format, ...) {
char **tokens, **fieldnames;
unsigned int curidx = 0, numtokens = 0, uflag;
va_list ap;
if (!RESULT) return DBI_FIELD_ERROR;
numtokens = _parse_field_formatstr(format, &tokens, &fieldnames);
if (numtokens == DBI_FIELD_ERROR) {
return numtokens;
}
va_start(ap, format);
while (curidx < numtokens) {
uflag = strlen(tokens[curidx]) > 1 && tokens[curidx][0] == 'u';
switch (tokens[curidx][strlen(tokens[curidx])-1]) {
case 'c': /* char */
if (uflag) /* unsigned */
*va_arg(ap, unsigned char *) = dbi_result_get_uchar(Result, fieldnames[curidx]);
else
*va_arg(ap, char *) = dbi_result_get_char(Result, fieldnames[curidx]);
break;
case 'h': /* sHort ("S"tring was taken) */
if (uflag) /* unsigned */
*va_arg(ap, unsigned short *) = dbi_result_get_ushort(Result, fieldnames[curidx]);
else
*va_arg(ap, short *) = dbi_result_get_short(Result, fieldnames[curidx]);
break;
case 'l': /* 4-byte integer (both l and i work) */
case 'i':
if (uflag) /* unsigned */
*va_arg(ap, unsigned int *) = dbi_result_get_uint(Result, fieldnames[curidx]);
else
*va_arg(ap, int *) = dbi_result_get_int(Result, fieldnames[curidx]);
break;
case 'L': /* long long */
if (uflag) /* unsigned */
*va_arg(ap, unsigned long long *) = dbi_result_get_ulonglong(Result, fieldnames[curidx]);
else
*va_arg(ap, long long *) = dbi_result_get_longlong(Result, fieldnames[curidx]);
break;
case 'f': /* float */
*va_arg(ap, float *) = dbi_result_get_float(Result, fieldnames[curidx]);
break;
case 'd': /* double */
*va_arg(ap, double *) = dbi_result_get_double(Result, fieldnames[curidx]);
break;
case 's': /* string */
*va_arg(ap, const char **) = dbi_result_get_string(Result, fieldnames[curidx]);
break;
case 'b': /* binary */
*va_arg(ap, const unsigned char **) = dbi_result_get_binary(Result, fieldnames[curidx]);
break;
case 'S': /* string copy */
*va_arg(ap, char **) = dbi_result_get_string_copy(Result, fieldnames[curidx]);
break;
case 'B': /* binary copy */
*va_arg(ap, unsigned char **) = dbi_result_get_binary_copy(Result, fieldnames[curidx]);
break;
case 'm': /* datetiMe (what... you have any better ideas?? */
*va_arg(ap, time_t *) = dbi_result_get_datetime(Result, fieldnames[curidx]);
break;
}
curidx++;
}
va_end(ap);
_free_string_list(tokens, numtokens);
_free_string_list(fieldnames, numtokens);
return numtokens;
}
unsigned int dbi_result_get_ulong(dbi_result Result, const char *fieldname) {
return dbi_result_get_uint(Result, fieldname);
}
