int rpserver_db_authenticate(dbi_conn db, const char *user, const char *password) { int retval = AUTH_UNKNOWN_USER; dbi_result result; LOG(LOG_INFO, "%s():%d - username: %s password: %s", __FUNCTION__, __LINE__, user, password); return 0; result = dbi_conn_queryf(db, "SELECT * FROM `users` WHERE `username` = '%s' AND `password` = MD5('%s')", user, password); LOG(LOG_INFO, "%s():%d - SELECT * FROM `users` WHERE `username` = '%s' AND `password` = '%s'", __FUNCTION__, __LINE__, user, password); if (result) { if( dbi_result_get_numrows(result) == 1 ) { while (dbi_result_next_row(result)) { LOG(LOG_INFO, "%s():%d - User \"%s\" is known and ACTIVE.", __FUNCTION__, __LINE__, user); retval = AUTH_VALID; } } else { LOG(LOG_INFO, "%s():%d - User \"%s\" is unknown", __FUNCTION__, __LINE__, user); } } dbi_result_free(result); return retval; }
int dbiw_res_num_rows(db_wrap_result * self, size_t *num) { RES_DECL(DB_WRAP_E_BAD_ARG); if (! num) return DB_WRAP_E_BAD_ARG; *num = dbi_result_get_numrows(dbires); return 0; }
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; }
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; }
int dbi_result_has_next_row(dbi_result Result) { if (!RESULT) { _error_handler(/*RESULT->conn*/ NULL, DBI_ERROR_BADPTR); return 0; } return RESULT->result_state != NOTHING_RETURNED && RESULT->currowidx < dbi_result_get_numrows(Result); }
/* This is used too early to call GncDbiProvider::get_table_list(). */ static bool save_may_clobber_data (dbi_conn conn, const std::string& dbname) { /* Data may be clobbered iff the number of tables != 0 */ auto result = dbi_conn_get_table_list (conn, dbname.c_str(), nullptr); bool retval = false; if (result) { retval = dbi_result_get_numrows (result) > 0; dbi_result_free (result); } return retval; }
///////////////////////////////////////////////////////////////////////////////// // // Function: // // Purpose: // // Parameters: // // Return value: // // Author: Komatsu Yuji(Zheng Chuyu) // ///////////////////////////////////////////////////////////////////////////////// int dateconds_execute(const apr_uint64_t proc_jobunit_id, const time_t base_time, const int beginning_of_week) { int rc, rv; dbi_result result; datecond_t *obj = NULL; struct tm *tm = NULL; jhklog_trace ("In %s() proc_jobunit_id: %llu, base_time: %ld, beginning_of_week: %d", __func__, proc_jobunit_id, base_time, beginning_of_week); result = jhkdb_select ("SELECT * FROM proc_dateconds WHERE proc_jobunit_id = %llu", proc_jobunit_id); if (result == NULL) return -1; // unset date conditions if (dbi_result_get_numrows(result) == 0) { dbi_result_free(result); return CONNECTOR_KIND_NORMAL; } // init rc = -1; obj = datecond_new(); // date condition while (dbi_result_next_row(result)) { datecond_load(obj, result); rv = datecond_execute(obj, base_time, beginning_of_week); if (rv == JHAKO_FALSE) continue; if (rv == JHAKO_TRUE) { rc = CONNECTOR_KIND_NORMAL; } else { rc = CONNECTOR_KIND_ERROR; } goto finish; } rc = CONNECTOR_KIND_BRANCH; finish: datecond_destroy(obj); dbi_result_free(result); return rc; }
///////////////////////////////////////////////////////////////////////////////// // // Function: // // Purpose: // // Parameters: // // Return value: // // Author: Komatsu Yuji(Zheng Chuyu) // ///////////////////////////////////////////////////////////////////////////////// int winjob_load_one(winjob_t * obj, dbi_result res) { apr_uint64_t num; jhklog_trace("In %s()", __func__); if (obj == NULL || res == NULL) return -1; num = dbi_result_get_numrows(res); if (num != 1) { jhklog_warn("In %s() can not find winjob. numrows: %llu", __func__, num); return 1; } while (dbi_result_next_row(res)) { winjob_load(obj, res); break; } return 0; }
//******************************************************************* // retrieve the definitions + status // get it from the cache. if there but too old: delete // If a probe definition does not exist, it will be created. // in case of mysql-has-gone-away type errors, we keep on running, // it will be caught later-on. //******************************************************************* void *bb_cpu_get_def(trx *t, int create) { struct probe_def *def; struct bb_cpu_result *res = (struct bb_cpu_result *)t->res; dbi_result result; time_t now = time(NULL); if (res->color != STAT_PURPLE && res->server == 0) { // first we find the serverid, this will be used to find the probe definition in the hashtable result = db_query(t->probe->db, 0, query_server_by_name, res->hostname, res->hostname, res->hostname, res->hostname, res->hostname); if (!result) { return(NULL); } if (dbi_result_next_row(result)) { res->server = dbi_result_get_int_idx(result, 0); } else { LOG(LOG_NOTICE, "%s:%u@%s: server %s not found", res->realm, res->stattime, t->fromhost, res->hostname); dbi_result_free(result); return(NULL); } dbi_result_free(result); } // look in the cache for the def def = g_hash_table_lookup(t->probe->cache, &res->server); if (def && def->stamp < now - (120 + uw_rand(240))) { // older then 2 - 6 minutes? g_hash_table_remove(t->probe->cache, &res->server); def = NULL; } // if not there retrieve from database and insert in hash if (def == NULL) { def = g_malloc0(t->probe->def_size); def->stamp = time(NULL); def->server = res->server; def->pgroup = 1; strcpy(def->hide, "no"); // first find the definition based on the serverid result = db_query(t->probe->db, 0, "select id, yellow, red, contact, hide, email, sms, delay " "from pr_%s_def where server = '%u'", res->name, res->server); if (!result) { g_free(def); return(NULL); } if (dbi_result_get_numrows(result) == 0) { // DEF RECORD NOT FOUND char sequence[40]; // no def record found? Create one. dbi_result_free(result); result = db_query(t->probe->db, 0, "insert into pr_%s_def (server, description) values ('%u', '%s')", res->name, res->server, res->hostname); dbi_result_free(result); sprintf(sequence, "pr_%s_def_id_seq", res->name); def->probeid = dbi_conn_sequence_last(t->probe->db, sequence); LOG(LOG_NOTICE, "%s:%u@%s: pr_%s_def created for %s, id = %u", res->realm, res->stattime, t->fromhost, res->name, res->hostname, def->probeid); result = db_query(t->probe->db, 0, "select id, yellow, red, contact, hide, email, sms, delay " "from pr_%s_def where id = '%u'", res->name, def->probeid); } if (!dbi_result_next_row(result)) { LOG(LOG_NOTICE, "%s:%u@%s: no pr_%s_def found for server %u - skipped", res->realm, res->stattime, t->fromhost, res->name, res->server); dbi_result_free(result); g_free(def); return(NULL); } def->probeid = dbi_result_get_int(result, "id"); def->yellow = dbi_result_get_float(result, "yellow"); def->red = dbi_result_get_float(result, "red"); def->contact = dbi_result_get_int(result, "contact"); strcpy(def->hide, dbi_result_get_string_default(result, "hide", "no")); strcpy(def->email, dbi_result_get_string_default(result, "email", "")); strcpy(def->sms, dbi_result_get_string_default(result, "sms", "")); def->delay = dbi_result_get_int(result, "delay"); dbi_result_free(result); result = db_query(t->probe->db, 0, "select color " "from pr_status " "where class = '%u' and probe = '%u'", t->probe->class, def->probeid); if (result) { if (dbi_result_next_row(result)) { def->color = dbi_result_get_int(result, "color"); } else { LOG(LOG_NOTICE, "%s:%u@%s: pr_status record for %s id %u not found", res->realm, res->stattime, t->fromhost, res->name, def->probeid); } dbi_result_free(result); } if (!def->color) def->color = res->color; result = db_query(t->probe->db, 0, "select stattime from pr_%s_raw use index(probstat) " "where probe = '%u' order by stattime desc limit 1", res->name, def->probeid); if (result) { if (dbi_result_next_row(result)) { def->newest = dbi_result_get_int(result, "stattime"); } dbi_result_free(result); } g_hash_table_insert(t->probe->cache, guintdup(def->server), def); }
//******************************************************************* // SUMMARIZE A TABLE INTO AN OLDER PERIOD //******************************************************************* static void mysqlstats_summarize(trx *t, char *from, char *into, guint slot, guint slotlow, guint slothigh, gint resummarize) { dbi_result result; struct probe_def *def = (struct probe_def *)t->def; float avg_yellow, avg_red; int avg_selectq; int avg_insertq; int avg_updateq; int avg_deleteq; guint stattime; guint max_color; stattime = slotlow + ((slothigh-slotlow)/2); result = db_query(t->probe->db, 0, "select avg(selectq) as avg_selectq, avg(insertq) as avg_insertq, avg(updateq) as avg_updateq, " " avg(deleteq) as avg_deleteq, max(color) as max_color, avg(yellow) as avg_yellow, avg(red) as avg_red" "from pr_mysqlstats_%s use index(probstat) " "where probe = '%d' and stattime >= %d and stattime < %d", from, def->probeid, slotlow, slothigh); if (!result) return; if (dbi_result_get_numrows(result) == 0) { // no records found LOG(LOG_NOTICE, "nothing to summarize from %s for probe %u %u %u", from, def->probeid, slotlow, slothigh); dbi_result_free(result); return; } if (!dbi_result_next_row(result)) { dbi_result_free(result); return; } if (dbi_result_field_is_null_idx(result, 0)) { LOG(LOG_NOTICE, "nothing to summarize from %s for probe %u %u %u", from, def->probeid, slotlow, slothigh); dbi_result_free(result); return; } avg_selectq = dbi_result_get_int(result, "avg_selectq"); avg_insertq = dbi_result_get_int(result, "avg_insertq"); avg_updateq = dbi_result_get_int(result, "avg_updateq"); avg_deleteq = dbi_result_get_int(result, "avg_deleteq"); max_color = dbi_result_get_int(result, "max_color"); avg_yellow = dbi_result_get_float(result, "avg_yellow"); avg_red = dbi_result_get_float(result, "avg_red"); dbi_result_free(result); if (resummarize) { // delete old values result = db_query(t->probe->db, 0, "delete from pr_mysqlstats_%s where probe = '%u' and stattime = '%u'", into, def->probeid, stattime); dbi_result_free(result); } result = db_query(t->probe->db, 0, "insert into pr_mysqlstats_%s (selectq, insertq, updateq, deleteq, probe, color, stattime, " " yellow, red, slot) " " values ('%u', '%u', '%u', '%u', '%d', '%u', '%d', " " '%f', '%f', '%u')", into, avg_selectq, avg_insertq, avg_updateq, avg_deleteq, def->probeid, max_color, stattime, avg_yellow, avg_red, slot); dbi_result_free(result); }
//******************************************************************* // SUMMARIZE A TABLE INTO AN OLDER PERIOD //******************************************************************* static void bb_cpu_summarize(trx *t, char *from, char *into, guint slot, guint slotlow, guint slothigh, gint resummarize) { dbi_result result; struct probe_def *def = (struct probe_def *)t->def; float avg_yellow, avg_red; gfloat avg_loadavg; guint avg_user, avg_system, avg_idle; guint avg_swapped, avg_free, avg_buffered, avg_cached, avg_used; guint stattime; guint max_color; stattime = slotlow + ((slothigh-slotlow)/2); result = db_query(t->probe->db, 0, "select avg(loadavg) as avg_loadavg, avg(user) as avg_user, avg(system) as avg_system, " " avg(idle) as avg_idle, avg(swapped) as avg_swapped, avg(free) as avg_free, " " avg(buffered) as avg_buffered, avg(cached) as avg_cached, avg(used) as avg_used, " " max(color) as max_color, avg(yellow) as avg_yellow, avg(red) as avg_red " "from pr_bb_cpu_%s use index(probstat) " "where probe = '%d' and stattime >= %d and stattime < %d", from, def->probeid, slotlow, slothigh); if (!result) return; if (dbi_result_get_numrows(result) == 0) { // no records found LOG(LOG_NOTICE, "nothing to summarize from %s for probe %u %u %u", from, def->probeid, slotlow, slothigh); dbi_result_free(result); return; } if (!dbi_result_next_row(result)) { dbi_result_free(result); return; } if (dbi_result_field_is_null_idx(result, 0)) { LOG(LOG_NOTICE, "nothing to summarize from %s for probe %u %u %u", from, def->probeid, slotlow, slothigh); dbi_result_free(result); return; } avg_loadavg = dbi_result_get_float(result, "avg_loadavg"); avg_user = dbi_result_get_int(result, "avg_user"); avg_system = dbi_result_get_int(result, "avg_system"); avg_idle = dbi_result_get_int(result, "avg_idle"); avg_swapped = dbi_result_get_int(result, "avg_swapped"); avg_free = dbi_result_get_int(result, "avg_free"); avg_buffered= dbi_result_get_int(result, "avg_buffered"); avg_cached = dbi_result_get_int(result, "avg_cached"); avg_used = dbi_result_get_int(result, "avg_used"); max_color = dbi_result_get_int(result, "max_color"); avg_yellow = dbi_result_get_float(result, "avg_yellow"); avg_red = dbi_result_get_float(result, "avg_red"); dbi_result_free(result); if (resummarize) { // delete old values result = db_query(t->probe->db, 0, "delete from pr_bb_cpu_%s where probe = '%u' and stattime = '%u'", into, def->probeid, stattime); dbi_result_free(result); } result = db_query(t->probe->db, 0, "insert into pr_bb_cpu_%s (loadavg, user, system, idle, swapped, free, buffered, cached, " " used, probe, color, stattime, yellow, red, slot) " " values ('%f', '%u', '%u', '%u', '%u', '%u', '%u', '%u', " " '%u', '%d', '%u', '%d', '%f', '%f', '%u')", into, avg_loadavg, avg_user, avg_system, avg_idle, avg_swapped, avg_free, avg_buffered, avg_cached, avg_used, def->probeid, max_color, stattime, avg_yellow, avg_red, slot); dbi_result_free(result); }
int dbi_result_last_row(dbi_result Result) { return dbi_result_seek_row(Result, dbi_result_get_numrows(Result)); }
//******************************************************************* // retrieve the definitions + status // get it from the cache. if there but too old: delete // If a probe definition does not exist, it will be created. // in case of mysql-has-gone-away type errors, we keep on running, // it will be caught later-on. //******************************************************************* void *bb_get_def(trx *t, int create) { struct probe_def *def; struct bb_result *res = (struct bb_result *)t->res; dbi_result result; def = g_malloc0(t->probe->def_size); def->stamp = time(NULL); def->server = res->server; def->pgroup = 1; strcpy(def->hide, "no"); if (res->color == STAT_PURPLE && res->probeid) { // find the definition based on the probe id result = db_query(t->probe->db, 0, "select id, contact, hide, email, sms, delay from pr_bb_def " "where id = '%u'", res->probeid); if (!result) { g_free(def); return(NULL); } } else { if (res->server == 0) { // first we find the serverid, this will be used to find the probe definition in the database if (!query_server_by_name) { LOG(LOG_WARNING, "%s:%u@%s: don't know how to find %s by name", res->realm, res->stattime, t->fromhost, res->hostname); g_free(def); return(NULL); } result = db_query(t->probe->db, 0, query_server_by_name, res->hostname, res->hostname, res->hostname, res->hostname, res->hostname); if (!result) { g_free(def); return(NULL); } if (dbi_result_next_row(result)) { res->server = dbi_result_get_int_idx(result, 0); } else { LOG(LOG_WARNING, "%s:%u@%s: server %s not found", res->realm, res->stattime, t->fromhost, res->hostname); dbi_result_free(result); g_free(def); return(NULL); } dbi_result_free(result); } // first find the definition based on the serverid result = db_query(t->probe->db, 0, "select id, contact, hide, email, sms, delay from pr_bb_def " "where bbname = '%s' and server = '%u'", res->bbname, res->server); if (!result) { g_free(def); return(NULL); } } if (dbi_result_get_numrows(result) == 0) { // DEF RECORD NOT FOUND char sequence[40]; dbi_result_free(result); result = db_query(t->probe->db, 0, "insert into pr_%s_def (server, ipaddress, description, bbname) " " values ('%u', '%s', '%s', '%s')", res->name, res->server, res->ipaddress ? res->ipaddress : "", res->hostname, res->bbname); dbi_result_free(result); sprintf(sequence, "pr_%s_def_id_seq", res->name); def->probeid = dbi_conn_sequence_last(t->probe->db, sequence); LOG(LOG_NOTICE, "%s:%u@%s: pr_bb_def %s created for %s, id = %u", res->realm, res->stattime, t->fromhost, res->bbname, res->hostname, def->probeid); result = db_query(t->probe->db, 0, "select id, contact, hide, email, sms, delay from pr_bb_def " "where bbname = '%s' and server = '%u'", res->bbname, res->server); if (!result) return(NULL); } if (!dbi_result_next_row(result)) { LOG(LOG_NOTICE, "%s:%u@%s: no pr_%s_def found for server %u - skipped", res->realm, res->stattime, t->fromhost, res->name, res->server); dbi_result_free(result); return(NULL); } def->probeid = dbi_result_get_int(result, "id"); def->contact = dbi_result_get_int(result, "contact"); strcpy(def->hide, dbi_result_get_string_default(result, "hide", "no")); strcpy(def->email, dbi_result_get_string_default(result, "email", "")); strcpy(def->sms, dbi_result_get_string_default(result, "sms", "")); def->delay = dbi_result_get_int(result, "delay"); dbi_result_free(result); // definition found, get the pr_status result = db_query(t->probe->db, 0, "select color, stattime " "from pr_status " "where class = '%u' and probe = '%u'", t->probe->class, def->probeid); if (result) { if (dbi_result_next_row(result)) { def->color = dbi_result_get_int(result, "color"); def->newest = dbi_result_get_int(result, "stattime"); } else { LOG(LOG_NOTICE, "%s:%u@%s: pr_status record for %s id %u (server %s) not found", res->realm, res->stattime, t->fromhost, res->name, def->probeid, res->hostname); } dbi_result_free(result); } if (!def->color) def->color = res->color; res->probeid = def->probeid; return(def); }
static ftpd_chroot_status_t ftpd_dbi_map_chroot(const request_rec *r, const char **ret_chroot, const char **ret_initroot) { ftpd_chroot_status_t ARV = FTPD_CHROOT_USER_NOT_FOUND; ftpd_dbi_config *conf; const char *query; const char *chroot; ftpd_dbi_rest *dbi_res; dbi_result result; ftpd_dbi_dconfig *dconf = ap_get_module_config(r->per_dir_config, &ftpd_dbi_module); conf = apr_hash_get(ftpd_dbi_config_hash, dconf->id, APR_HASH_KEY_STRING); if (conf == NULL) { ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "[mod_ftpd_dbi.c] - Server Config for \"%s\" was not found", dconf->id); return FTPD_CHROOT_FAIL; } ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "[mod_ftpd_dbi.c] Attempting to Acquire DBI Connection"); apr_reslist_acquire(conf->pool, (void **) &dbi_res); /* make the query to get the user's password */ if (conf->rec.isactive_field) { if (conf->rec.chroot_query == NULL) { query = "SELECT &{ChrootField} FROM &{Table} WHERE &{UsernameField}=&{GivenUsername} AND &{IsActiveField}!=0 LIMIT 0,1"; } else { query = conf->rec.chroot_query; } } else { if (conf->rec.chroot_query == NULL) { query = "SELECT &{ChrootField} FROM &{Table} WHERE &{UsernameField}=&{GivenUsername} LIMIT 0,1"; } else { query = conf->rec.chroot_query; } } /* perform the query */ if ((query = populate_querystring(r, query, conf, dconf, dbi_res, r->user)) && safe_dbi_query(dbi_res, &result, r, query) == 0) { /* store the query result */ if (dbi_result_next_row(result) && dbi_result_get_numrows(result) == 1) { chroot = dbi_result_get_string_copy(result, conf->rec.chroot_field); if ((chroot == NULL) || (strcmp(chroot, "ERROR") == 0)) { ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "[mod_ftpd_dbi.c] - libdbi returned an error when retrieving the chroot."); ARV = FTPD_CHROOT_FAIL; } else { // XXXX: Do more checks of the chroot here! *ret_chroot = apr_pstrdup(r->pool, chroot); ARV = FTPD_CHROOT_USER_FOUND; } } else { if (dbi_result_get_numrows(result) == 0) { ARV = FTPD_CHROOT_USER_NOT_FOUND; } else { ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "[mod_ftpd_dbi.c] %lu row(s) was not returned by dbi_result_get_numrows(result)", (unsigned long) dbi_result_get_numrows(result)); ARV = FTPD_CHROOT_FAIL; } } dbi_result_free(result); } else { ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "[mod_ftpd_dbi.c] Query Failed!"); ARV = FTPD_CHROOT_FAIL; } safe_dbi_rel_server(conf->pool, dbi_res, r); return ARV; }