/**
* Add a new registration to the database
*
* @param c the db configuration
* @param s the server
* @param r the registration
*
* @return 1 on success
*/
int db_add_registration(struct config *c, struct server *s, struct registration *r)
{
char *req = "INSERT INTO registrations (server_id, serveradmin, name, password) VALUES (%i, %i, %s, %s);";
char *quoted_name, *quoted_pass;
dbi_result res;
struct channel *ch;
struct player_channel_privilege *priv;
size_t iter, iter2;
dbi_conn_quote_string_copy(c->conn, r->name, "ed_name);
dbi_conn_quote_string_copy(c->conn, r->password, "ed_pass);
res = dbi_conn_queryf(c->conn, req, s->id, r->global_flags, quoted_name, quoted_pass);
if (res == NULL) {
logger(LOG_WARN, "db_add_registration : SQL query failed");
} else {
r->db_id = dbi_conn_sequence_last(c->conn, NULL);
dbi_result_free(res);
}
free(quoted_pass);
free(quoted_name);
ar_each(struct channel *, ch, iter, s->chans)
ar_each(struct player_channel_privilege *, priv, iter2, ch->pl_privileges)
if (priv->reg == PL_CH_PRIV_REGISTERED && priv->pl_or_reg.reg == r) {
logger(LOG_INFO, "db_add_registration : adding a new pl_chan_priv");
db_add_pl_chan_priv(c, priv);
}
ar_end_each;
ar_end_each;
return 1;
}
size_t dbi_conn_quote_string(dbi_conn Conn, char **orig) {
dbi_conn_t *conn = Conn;
char *temp = NULL;
char *newstr = NULL;
size_t newlen;
if (!conn) {
return 0;
}
_reset_conn_error(conn);
if (!orig || !*orig) {
_error_handler(conn, DBI_ERROR_BADPTR);
return 0;
}
newlen = dbi_conn_quote_string_copy(Conn, *orig, &newstr);
if (!newlen) {
/* leave original string alone in case of an error */
/* error number was set by called function */
return 0;
}
temp = *orig;
*orig = newstr;
free(temp); /* original unescaped string */
return newlen;
}
size_t dbiw_sql_quote(db_wrap * self, char const * sql, size_t len, char ** dest)
{
DB_DECL(0);
if (!sql || !*sql || !len)
{
*dest = NULL;
return 0;
}
else
{
return dbi_conn_quote_string_copy(conn, sql, dest);
}
}
size_t dbi_conn_escape_string_copy(dbi_conn Conn, const char *orig, char **newquoted) {
size_t newlen;
if (!Conn) {
return 0;
}
newlen = dbi_conn_quote_string_copy(Conn, orig, newquoted);
if (newlen) {
(*newquoted)[newlen-1] = '\0';
memmove(*newquoted, (*newquoted)+1, newlen-1);
}
return newlen-2;
}
//*******************************************************************
// CREATE PR_STATUS RECORD
//*******************************************************************
static void insert_pr_status(trx *t)
{
dbi_result result;
char *escmsg;
if (t->res->message) {
dbi_conn_quote_string_copy(t->probe->db->conn, t->res->message, &escmsg);
} else {
escmsg = strdup("");
}
result = db_query(t->probe->db, 0,
"insert into pr_status (class, probe, stattime, expires, color, server, message, contact, hide)"
" values ('%u', '%u', '%u', '%u', '%u', '%u', '%s', '%u', '%s')",
t->probe->class, t->def->probeid, t->res->stattime, t->res->expires,
t->def->color, t->def->server, escmsg, t->def->contact, t->def->hide);
dbi_result_free(result);
free(escmsg);
}
//*******************************************************************
// UPDATE PR_STATUS
//*******************************************************************
static void update_pr_status(trx *t, struct probe_result *prv)
{
dbi_result result;
char *qry;
qry = g_malloc(512 + (t->res->message ? strlen(t->res->message)*2 : 0));
sprintf(qry, "update pr_status "
"set stattime = '%u', expires = '%u', hide = '%s', "
" contact = '%u', server = '%u'",
t->res->stattime, t->res->expires, t->def->hide,
t->def->contact, t->def->server);
if (t->probe->fuse) {
if (t->res->color > prv->color || prv->color == STAT_PURPLE) {
// if this probe acts like a fuse, only update color if new color is higher then old color
// because colors must be set to green (= fuse replaced) by a human
sprintf(&qry[strlen(qry)], ", color = '%u'", t->res->color);
}
} else {
sprintf(&qry[strlen(qry)], ", color = '%u'", t->res->color);
}
if (t->res->message) {
char *escmsg;
dbi_conn_quote_string_copy(t->probe->db->conn, t->res->message, &escmsg);
if (t->res->color != prv->color) {
sprintf(&qry[strlen(qry)], ", message = '%s'", escmsg);
} else if (t->probe->fuse) {
sprintf(&qry[strlen(qry)], ", message = concat(message,'%s')", escmsg);
}
free(escmsg);
}
else {
sprintf(&qry[strlen(qry)],", message = ''");
}
sprintf(&qry[strlen(qry)], " where probe = '%u' and class = '%u'", t->def->probeid, t->probe->class);
result = db_rawquery(t->probe->db, 0, qry);
dbi_result_free(result);
g_free(qry);
}
//*******************************************************************
// CREATE PR_HIST
//*******************************************************************
static void create_pr_hist(trx *t, struct probe_result *prv)
{
dbi_result result;
char *escmsg;
if (t->res->message) {
dbi_conn_quote_string_copy(t->probe->db->conn, t->res->message, &escmsg);
} else {
escmsg = strdup("");
}
result = db_query(t->probe->db, 0,
"insert into pr_hist (server, class, probe, stattime, prv_color, color, message, contact, hide, pgroup)"
" values ('%u', '%u', '%u', '%u', '%d', '%d', '%s', '%u', '%s', '%u')",
t->def->server, t->probe->class, t->def->probeid, t->res->stattime,
/* (t->res->received > t->res->expires) ? STAT_PURPLE : */ prv->color,
t->res->color, escmsg, t->def->contact, t->def->hide, t->def->pgroup);
dbi_result_free(result);
free(escmsg);
}
//*******************************************************************
// STORE RAW RESULTS
//*******************************************************************
static gint mysqlstats_store_raw_result(trx *t)
{
dbi_result result;
struct mysqlstats_result *res = (struct mysqlstats_result *)t->res;
struct probe_def *def = (struct probe_def *)t->def;
char *escmsg;
const char *errmsg;
if (t->res->color == STAT_PURPLE) return 1;
t->seen_before = FALSE;
if (res->message) {
dbi_conn_quote_string_copy(t->probe->db->conn, t->res->message, &escmsg);
} else {
escmsg = strdup("");
}
result = db_query(t->probe->db, 0,
"insert into pr_mysqlstats_raw (probe, yellow, red, stattime, color, selectq, insertq, "
" updateq, deleteq, message) "
" values ('%u', '%f', '%f', '%u', '%u', '%u', '%u', "
" '%u', '%u', '%s')",
def->probeid, def->yellow, def->red, res->stattime, res->color,
res->selectq, res->insertq, res->updateq, res->deleteq,escmsg);
g_free(escmsg);
if (result) {
dbi_result_free(result);
return 1; // success
}
if (dbi_duplicate_entry(t->probe->db->conn)) {
t->seen_before = TRUE;
return 1; // success
}
if (dbi_conn_error(t->probe->db->conn, &errmsg) == DBI_ERROR_NONE) {
return 1; // success
}
LOG(LOG_ERR, "%s", errmsg);
return 0; // Failure
}
//*******************************************************************
// STORE RAW RESULTS
//*******************************************************************
static gint bb_cpu_store_raw_result(trx *t)
{
dbi_result result;
struct bb_cpu_result *res = (struct bb_cpu_result *)t->res;
struct probe_def *def = (struct probe_def *)t->def;
char *escmsg;
const char *errmsg;
if (t->res->color == STAT_PURPLE) return 1;
t->seen_before = FALSE;
if (res->message) {
dbi_conn_quote_string_copy(t->probe->db->conn, t->res->message, &escmsg);
} else {
escmsg = strdup("");
}
result = db_query(t->probe->db, 0,
"insert into pr_bb_cpu_raw (probe, stattime, color, loadavg, user, idle, free, used, message)"
" values ('%u', '%u', '%u', '%f', '%u', '%u', '%u', '%u', '%s')",
def->probeid, res->stattime, res->color, res->loadavg,
res->user, res->idle, res->free, res->used, escmsg);
g_free(escmsg);
if (result) {
dbi_result_free(result);
return 1; // success
}
if (dbi_duplicate_entry(t->probe->db->conn)) {
t->seen_before = TRUE;
return 1; // success
}
if (dbi_conn_error(t->probe->db->conn, &errmsg) == DBI_ERROR_NONE) {
return 1; // success
}
LOG(LOG_ERR, "%s", errmsg);
return 0; // Failure
}
static GString *
afsql_dd_build_insert_command(AFSqlDestDriver *self, LogMessage *msg, GString *table)
{
GString *insert_command = g_string_sized_new(256);
GString *value = g_string_sized_new(512);
gint i, j;
g_string_printf(insert_command, "INSERT INTO %s (", table->str);
for (i = 0; i < self->fields_len; i++)
{
if ((self->fields[i].flags & AFSQL_FF_DEFAULT) == 0 && self->fields[i].value != NULL)
{
g_string_append(insert_command, self->fields[i].name);
j = i + 1;
while (j < self->fields_len && (self->fields[j].flags & AFSQL_FF_DEFAULT) == AFSQL_FF_DEFAULT)
j++;
if (j < self->fields_len)
g_string_append(insert_command, ", ");
}
}
g_string_append(insert_command, ") VALUES (");
for (i = 0; i < self->fields_len; i++)
{
gchar *quoted;
if ((self->fields[i].flags & AFSQL_FF_DEFAULT) == 0 && self->fields[i].value != NULL)
{
log_template_format(self->fields[i].value, msg, &self->template_options, LTZ_SEND, self->seq_num, NULL, value);
if (self->null_value && strcmp(self->null_value, value->str) == 0)
{
g_string_append(insert_command, "NULL");
}
else
{
dbi_conn_quote_string_copy(self->dbi_ctx, value->str, "ed);
if (quoted)
{
g_string_append(insert_command, quoted);
free(quoted);
}
else
{
g_string_append(insert_command, "''");
}
}
j = i + 1;
while (j < self->fields_len && (self->fields[j].flags & AFSQL_FF_DEFAULT) == AFSQL_FF_DEFAULT)
j++;
if (j < self->fields_len)
g_string_append(insert_command, ", ");
}
}
g_string_append(insert_command, ")");
g_string_free(value, TRUE);
return insert_command;
}
static GString *
afsql_dd_construct_query(AFSqlDestDriver *self, GString *table,
LogMessage *msg)
{
GString *value;
GString *query_string;
gint i;
value = g_string_sized_new(256);
query_string = g_string_sized_new(512);
g_string_printf(query_string, "INSERT INTO %s (", table->str);
for (i = 0; i < self->fields_len; i++)
{
g_string_append(query_string, self->fields[i].name);
if (i != self->fields_len - 1)
g_string_append(query_string, ", ");
}
g_string_append(query_string, ") VALUES (");
for (i = 0; i < self->fields_len; i++)
{
gchar *quoted;
if (self->fields[i].value == NULL)
{
/* the config used the 'default' value for this column -> the fields[i].value is NULL, use SQL default */
g_string_append(query_string, "DEFAULT");
}
else
{
log_template_format(self->fields[i].value, msg, &self->template_options, LTZ_SEND, self->seq_num, NULL, value);
if (self->null_value && strcmp(self->null_value, value->str) == 0)
{
g_string_append(query_string, "NULL");
}
else
{
dbi_conn_quote_string_copy(self->dbi_ctx, value->str, "ed);
if (quoted)
{
g_string_append(query_string, quoted);
free(quoted);
}
else
{
g_string_append(query_string, "''");
}
}
}
if (i != self->fields_len - 1)
g_string_append(query_string, ", ");
}
g_string_append(query_string, ")");
g_string_free(value, TRUE);
return query_string;
}
char *cache_create_database_string(TALLOC_CTX *ctx,struct cache_entry *entry,
struct configuration_data *conf)
{
/*
* create a database string from the given metadata in a cache entry
*/
char *retstr=NULL;
/**
* qoute required strings, that need potientially be qouted
* .. allocate other quote in the specific functions
* We are bound to not use talloc here.
*/
char *username;
char *share;
char *domain;
char *timestamp;
char *usersid;
/* fn depending strings */
char *source, *destination, *result, *filename, *mode;
dbi_conn_quote_string_copy( conf->DBIconn, entry->username, &username);
dbi_conn_quote_string_copy( conf->DBIconn, entry->share, &share);
dbi_conn_quote_string_copy( conf->DBIconn, entry->domain, &domain);
dbi_conn_quote_string_copy( conf->DBIconn, entry->timestamp, ×tamp);
dbi_conn_quote_string_copy( conf->DBIconn, entry->usersid, &usersid);
switch( entry->op_id ) {
case vfs_id_rename: ;
dbi_conn_quote_string_copy( conf->DBIconn, entry->source,
&source);
dbi_conn_quote_string_copy( conf->DBIconn, entry->destination,
&destination);
dbi_conn_quote_string_copy( conf->DBIconn, entry->result,
&result);
retstr = talloc_asprintf(ctx, "INSERT INTO data ("
"vfs_id, username, usersid, share, domain, timestamp,"
"string1, string2, result) VALUES ("
"%i, %s,%s,%s,%s,"
"%s,%s,%s,%s);",
entry->op_id,username,usersid,share,domain,timestamp,
source,destination,result);
free(source);
free(destination);
free(result);
break;
case vfs_id_close: ;
dbi_conn_quote_string_copy( conf->DBIconn, entry->filename, &filename);
dbi_conn_quote_string_copy( conf->DBIconn, entry->result, &result);
retstr = talloc_asprintf(ctx, "INSERT INTO data ("
"vfs_id, username, usersid, share, domain, timestamp,"
"string1, result) VALUES ("
"%i,%s,%s,%s,%s,"
"%s,%s,%s);",
entry->op_id,username,usersid,share,domain,timestamp,
filename,result);
free(result);
free(filename);
break;
case vfs_id_open: ;
dbi_conn_quote_string_copy( conf->DBIconn, entry->filename, &filename);
dbi_conn_quote_string_copy( conf->DBIconn, entry->mode, &mode);
dbi_conn_quote_string_copy( conf->DBIconn, entry->result, &result);
retstr = talloc_asprintf(ctx, "INSERT INTO data ("
"vfs_id, username, usersid, share, domain, timestamp,"
"string1, string2, result) VALUES ("
"%i,%s,%s,%s,%s,"
"%s,%s,%s,%s);",
entry->op_id,username,usersid,share,domain,timestamp,
filename,mode,result);
free(mode);
free(result);
free(filename);
break;
case vfs_id_chdir: ;
char *path;
dbi_conn_quote_string_copy( conf->DBIconn, entry->path, &path);
dbi_conn_quote_string_copy( conf->DBIconn, entry->result, &result);
retstr = talloc_asprintf( ctx, "INSERT INTO data ("
"vfs_id, username, usersid, share, domain, timestamp,"
"string1, result) VALUES ("
"%i,%s,%s,%s,%s,"
"%s,%s,%s);",
entry->op_id,username,usersid,share,domain,timestamp,
path,result);
free(path);
free(result);
break;
case vfs_id_mkdir: ;
dbi_conn_quote_string_copy( conf->DBIconn, entry->path, &path);
dbi_conn_quote_string_copy( conf->DBIconn, entry->mode, &mode);
dbi_conn_quote_string_copy( conf->DBIconn, entry->result, &result);
retstr = talloc_asprintf(ctx, "INSERT INTO data ("
"vfs_id, username, usersid, share, domain, timestamp,"
"string1, string2, result) VALUES ("
"%i,%s,%s,%s,%s,"
"%s,%s,%s,%s);",
entry->op_id,username,usersid,share,domain,timestamp,
path, mode, result);
free(mode);
free(result);
free(path);
break;
case vfs_id_write:
case vfs_id_pwrite: ;
if (entry->len == 0) {
retstr=NULL;
break;
}
dbi_conn_quote_string_copy( conf->DBIconn, entry->filename, &filename);
retstr = talloc_asprintf(ctx, "INSERT INTO data ("
"vfs_id, username, usersid, share, domain, timestamp,"
"string1, length) VALUES ("
"%i,%s,%s,%s,%s,%s,"
"%s,%lu);",
vfs_id_write,username,usersid,share,domain,timestamp,
filename,entry->len);
free(filename);
break;
case vfs_id_read:
case vfs_id_pread: ;
if (entry->len == 0) {
retstr=NULL;
break;
}
dbi_conn_quote_string_copy( conf->DBIconn, entry->filename, &filename);
retstr = talloc_asprintf(ctx, "INSERT INTO data ("
"vfs_id, username, usersid, share, domain, timestamp,"
"string1, length) VALUES ("
"%i,%s,%s,%s,%s,%s,"
"%s,%lu);",
vfs_id_read,username,usersid,share,domain,timestamp,
filename,entry->len);
free(filename);
break;
default: ;
}
free(username);
free(share);
free(domain);
free(timestamp);
free(usersid);
return retstr;
}
/**
* Make a channel persistent by inserting it into the database
*
* @param c the db config
* @param ch the channel to register
*
* @return 0 on failure, 1 on success
*/
int db_register_channel(struct config *c, struct channel *ch)
{
char *q = "INSERT INTO channels \
(server_id, name, topic, description, \
codec, maxusers, ordr, \
flag_default, flag_hierarchical, flag_moderated, \
parent_id, password) \
VALUES \
(%i, %s, %s, %s, \
%i, %i, %i, \
%i, %i, %i, \
%i, %s);";
char *name_clean, *topic_clean, *desc_clean, *pass_clean;
int flag_default, flag_hierar, flag_mod;
int insert_id, parent_id;
size_t iter;
struct channel *tmp_ch;
struct player_channel_privilege *priv;
dbi_result res;
if (ch->db_id != 0) /* already exists in the db */
return 0;
/* Secure the input before inserting */
dbi_conn_quote_string_copy(c->conn, ch->name, &name_clean);
dbi_conn_quote_string_copy(c->conn, ch->topic, &topic_clean);
dbi_conn_quote_string_copy(c->conn, ch->desc, &desc_clean);
dbi_conn_quote_string_copy(c->conn, ch->password, &pass_clean);
/* better here than in the query function */
flag_default = (ch->flags & CHANNEL_FLAG_DEFAULT);
flag_hierar = (ch->flags & CHANNEL_FLAG_SUBCHANNELS);
flag_mod = (ch->flags & CHANNEL_FLAG_MODERATED);
/* Add the ID of the parent or -1 */
if (ch->parent == NULL)
parent_id = 0xFFFFFFFF;
else
parent_id = ch->parent->db_id;
res = dbi_conn_queryf(c->conn, q,
ch->in_server->id, name_clean, topic_clean, desc_clean,
ch->codec, ch->players->max_slots, ch->sort_order,
flag_default, flag_hierar, flag_mod,
parent_id, pass_clean);
if (res == NULL) {
logger(LOG_ERR, "Insertion request failed : ");
logger(LOG_ERR, q, ch->in_server->id, name_clean, topic_clean, desc_clean,
ch->codec, ch->players->max_slots, ch->sort_order,
flag_default, flag_hierar, flag_mod,
parent_id, pass_clean);
}
insert_id = dbi_conn_sequence_last(c->conn, NULL);
ch->db_id = insert_id;
/* Register all the subchannels */
if (ch_getflags(ch) & CHANNEL_FLAG_SUBCHANNELS) {
ar_each(struct channel *, tmp_ch, iter, ch->subchannels)
db_register_channel(c, tmp_ch);
ar_end_each;
}
/* quote strings */
char * SMSDDBI_QuoteString(GSM_SMSDConfig * Config, const char *string)
{
char *encoded_text = NULL;
dbi_conn_quote_string_copy(Config->conn.dbi, string, &encoded_text);
return encoded_text;
}
