bool RemoveHostFromLastSeen(const char *hostname, char *hostkey)
{
char ip[CF_BUFSIZE];
char digest[CF_BUFSIZE] = { 0 };
if (!hostkey)
{
strcpy(ip, Hostname2IPString(hostname));
IPString2KeyDigest(ip, digest);
}
else
{
snprintf(digest, sizeof(digest), "%s", hostkey);
}
CF_DB *dbp;
char key[CF_BUFSIZE];
if (!OpenDB(&dbp, dbid_lastseen))
{
CfOut(cf_error, "", " !! Unable to open last seen DB");
return false;
}
snprintf(key, CF_BUFSIZE, "-%s", digest);
DeleteComplexKeyDB(dbp, key, strlen(key) + 1);
snprintf(key, CF_BUFSIZE, "+%s", digest);
DeleteComplexKeyDB(dbp, key, strlen(key) + 1);
CloseDB(dbp);
return true;
}
static Averages *GetCurrentAverages(char *timekey)
{
CF_DB *dbp;
static Averages entry;
if (!OpenDB(&dbp, dbid_observations))
{
return NULL;
}
memset(&entry, 0, sizeof(entry));
AGE++;
WAGE = AGE / SECONDS_PER_WEEK * CF_MEASURE_INTERVAL;
if (ReadDB(dbp, timekey, &entry, sizeof(Averages)))
{
int i;
for (i = 0; i < CF_OBSERVABLES; i++)
{
Log(LOG_LEVEL_DEBUG, "Previous values (%lf,..) for time index '%s'", entry.Q[i].expect, timekey);
}
}
else
{
Log(LOG_LEVEL_DEBUG, "No previous value for time index '%s'", timekey);
}
CloseDB(dbp);
return &entry;
}
static void test_newentry(void **context)
{
setup();
UpdateLastSawHost("SHA-12345", "127.0.0.64", true, 666);
DBHandle *db;
OpenDB(&db, dbid_lastseen);
KeyHostSeen q;
assert_int_equal(ReadDB(db, "qiSHA-12345", &q, sizeof(q)), true);
assert_int_equal(q.lastseen, 666);
assert_double_close(q.Q.q, 0.0);
assert_double_close(q.Q.dq, 0.0);
assert_double_close(q.Q.expect, 0.0);
assert_double_close(q.Q.var, 0.0);
assert_int_equal(ReadDB(db, "qoSHA-12345", &q, sizeof(q)), false);
char address[CF_BUFSIZE];
assert_int_equal(ReadDB(db, "kSHA-12345", address, sizeof(address)), true);
assert_string_equal(address, "127.0.0.64");
char hostkey[CF_BUFSIZE];
assert_int_equal(ReadDB(db, "a127.0.0.64", hostkey, sizeof(hostkey)), true);
assert_string_equal(hostkey, "SHA-12345");
CloseDB(db);
}
SQLConn(Module* m, const SQLhost& hi)
: mod(m), host(hi), login(NULL), sock(NULL), context(NULL)
{
if (OpenDB())
{
std::string query("USE " + host.name);
if (tds_submit_query(sock, query.c_str()) == TDS_SUCCEED)
{
if (tds_process_simple_query(sock) != TDS_SUCCEED)
{
LoggingMutex->Lock();
ServerInstance->Logs->Log("m_mssql",LOG_DEFAULT, "WARNING: Could not select database " + host.name + " for DB with id: " + host.id);
LoggingMutex->Unlock();
CloseDB();
}
}
else
{
LoggingMutex->Lock();
ServerInstance->Logs->Log("m_mssql",LOG_DEFAULT, "WARNING: Could not select database " + host.name + " for DB with id: " + host.id);
LoggingMutex->Unlock();
CloseDB();
}
}
else
{
LoggingMutex->Lock();
ServerInstance->Logs->Log("m_mssql",LOG_DEFAULT, "WARNING: Could not connect to DB with id: " + host.id);
LoggingMutex->Unlock();
CloseDB();
}
}
static void _MonUpload(const char *file, const char *metafile) {
DBG_Struct *dbg;
char *id,*buf;
size_t size;
if (!g_file_get_contents(file, &buf, &size, NULL)) {
g_warning("cannot read file:%s",file);
exit(1);
}
dbg = GetDBG_monsys();
dbg->dbt = NewNameHash();
if (OpenDB(dbg) != MCP_OK) {
g_warning("OpenDB failure");
exit(1);
}
monblob_setup(dbg, FALSE);
TransactionStart(dbg);
id = monblob_import_mem(dbg, NULL, 0, "monupload.bin", NULL, 0, buf, size);
g_free(buf);
TransactionEnd(dbg);
CloseDB(dbg);
AddMetaData(id, metafile);
xfree(id);
}
bool Address2Hostkey(const char *address, char *result)
{
result[0] = '\0';
if ((strcmp(address, "127.0.0.1") == 0) || (strcmp(address, "::1") == 0) || (strcmp(address, VIPADDRESS) == 0))
{
if (PUBKEY)
{
unsigned char digest[EVP_MAX_MD_SIZE + 1];
HashPubKey(PUBKEY, digest, CF_DEFAULT_DIGEST);
snprintf(result, CF_MAXVARSIZE, "%s", HashPrint(CF_DEFAULT_DIGEST, digest));
return true;
}
else
{
return false;
}
}
DBHandle *db;
if (!OpenDB(&db, dbid_lastseen))
{
return false;
}
bool ret = Address2HostkeyInDB(db, address, result);
CloseDB(db);
return ret;
}
void test_migrate_unqualified_names(void)
{
DBHandle *db = setup(true);
assert_int_equal(WriteDB(db, "foo", &dummy_event, sizeof(dummy_event)), true);
assert_int_equal(WriteDB(db, "q.bar", &dummy_event, sizeof(dummy_event)), true);
CloseDB(db);
assert_int_equal(OpenDB(&db, dbid_bundles), true);
/* Old entry migrated */
assert_int_equal(HasKeyDB(db, "foo", strlen("foo") + 1), false);
assert_int_equal(HasKeyDB(db, "default.foo", strlen("default.foo") + 1), true);
Event read_value = { 0 };
ReadDB(db, "default.foo", &read_value, sizeof(read_value));
assert_memory_equal(&read_value, &dummy_event, sizeof(dummy_event));
/* New entry preserved */
assert_int_equal(HasKeyDB(db, "q.bar", strlen("q.bar") + 1), true);
memset(&read_value, 0, sizeof(read_value));
ReadDB(db, "q.bar", &read_value, sizeof(read_value));
assert_memory_equal(&read_value, &dummy_event, sizeof(dummy_event));
/* Version marker */
assert_int_equal(HasKeyDB(db, "version", strlen("version") + 1), true);
CloseDB(db);
}
static void test_no_migration(void)
{
DBHandle *db = setup(true);
CloseDB(db);
/* Migration on empty DB should produce single "version" key */
assert_int_equal(OpenDB(&db, dbid_lastseen), true);
DBCursor *cursor;
assert_int_equal(NewDBCursor(db, &cursor), true);
char *key;
void *value;
int ksize, vsize;
while (NextDB(cursor, &key, &ksize, &value, &vsize))
{
assert_int_equal(ksize, strlen("version") + 1);
assert_string_equal(key, "version");
assert_int_equal(vsize, 2);
assert_string_equal(value, "1");
}
assert_int_equal(DeleteDBCursor(cursor), true);
CloseDB(db);
}
void test_iter_delete_entry(void **state)
{
/* Test that deleting entry under cursor does not interrupt iteration */
CF_DB *db;
assert_int_equal(OpenDB(&db, dbid_classes), true);
assert_int_equal(WriteDB(db, "foobar", "abc", 3), true);
assert_int_equal(WriteDB(db, "bazbaz", "def", 3), true);
assert_int_equal(WriteDB(db, "booo", "ghi", 3), true);
CF_DBC *cursor;
assert_int_equal(NewDBCursor(db, &cursor), true);
char *key;
int ksize;
void *value;
int vsize;
assert_int_equal(NextDB(db, cursor, &key, &ksize, &value, &vsize), true);
assert_int_equal(DBCursorDeleteEntry(cursor), true);
assert_int_equal(NextDB(db, cursor, &key, &ksize, &value, &vsize), true);
assert_int_equal(NextDB(db, cursor, &key, &ksize, &value, &vsize), true);
assert_int_equal(DeleteDBCursor(db, cursor), true);
CloseDB(db);
}
SQLConn(InspIRCd* SI, Module* m, const SQLhost& hi)
: ServerInstance(SI), mod(m), host(hi)
{
if (OpenDB() != SQLITE_OK)
{
ServerInstance->Logs->Log("m_sqlite3",DEFAULT, "WARNING: Could not open DB with id: " + host.id);
CloseDB();
}
}
static bool PurgeCurrentLastSeen()
{
CF_DB *db_conn = NULL;
CF_DBC *db_cursor = NULL;
char *key = NULL;
void *value = NULL;
int ksize = 0, vsize = 0;
if (!OpenDB(&db_conn, dbid_lastseen))
{
Log(LOG_LEVEL_ERR, "Unable to open lastseen db");
return false;
}
if (!NewDBCursor(db_conn, &db_cursor))
{
Log(LOG_LEVEL_ERR, "Unable to scan lastseen db");
CloseDB(db_conn);
return false;
}
while (NextDB(db_cursor, &key, &ksize, &value, &vsize))
{
/* Only read the 'quality of connection' entries */
if (key[0] != 'q')
{
continue;
}
time_t then = 0;
if (value != NULL)
{
if (sizeof(KeyHostSeen) < vsize)
{
Log(LOG_LEVEL_ERR, "Invalid entry in lastseen database.");
continue;
}
KeyHostSeen entry = { 0 };
memcpy(&entry, value, vsize);
then = entry.lastseen;
}
if (then - START_TIME > NHOSTS)
{
DBCursorDeleteEntry(db_cursor);
Log(LOG_LEVEL_DEBUG, "Deleting expired entry for %s", key);
continue;
}
}
DeleteDBCursor(db_cursor);
CloseDB(db_conn);
return true;
}
/**
* @brief removes all traces of host 'ip' from lastseen DB
*
* @param[in] ip : either in (SHA/MD5 format)
* @param[in,out] digest: return corresponding digest of input host.
* If NULL, return nothing
* @retval true if entry was deleted, false otherwise
*/
bool DeleteIpFromLastSeen(const char *ip, char *digest)
{
DBHandle *db;
bool res = false;
if (!OpenDB(&db, dbid_lastseen))
{
Log(LOG_LEVEL_ERR, "Unable to open lastseen database");
return false;
}
char bufkey[CF_BUFSIZE + 1];
char bufhost[CF_BUFSIZE + 1];
strcpy(bufhost, "a");
strlcat(bufhost, ip, CF_BUFSIZE);
char key[CF_BUFSIZE];
if (ReadDB(db, bufhost, &key, sizeof(key)) == true)
{
strcpy(bufkey, "k");
strlcat(bufkey, key, CF_BUFSIZE);
if (HasKeyDB(db, bufkey, strlen(bufkey) + 1) == false)
{
res = false;
goto clean;
}
else
{
if (digest != NULL)
{
strcpy(digest, bufkey);
}
DeleteDB(db, bufkey);
DeleteDB(db, bufhost);
res = true;
}
}
else
{
res = false;
goto clean;
}
strcpy(bufkey, "qi");
strlcat(bufkey, key, CF_BUFSIZE);
DeleteDB(db, bufkey);
strcpy(bufkey, "qo");
strlcat(bufkey, key, CF_BUFSIZE);
DeleteDB(db, bufkey);
clean:
CloseDB(db);
return res;
}
void test_migrate_single(const char *expected_old_key,
const char *expected_quality_key)
{
/* Test migration of single entry */
DBHandle *db = setup(true);
KeyHostSeen0 khs0 = {
.q = 666777.0,
.expect = 12345.0,
.var = 6543210.0,
};
strcpy(khs0.address, "1.2.3.4");
assert_int_equal(WriteDB(db, expected_old_key, &khs0, sizeof(khs0)), true);
CloseDB(db);
assert_int_equal(OpenDB(&db, dbid_lastseen), true);
/* Old entry migrated */
assert_int_equal(HasKeyDB(db, expected_old_key,
strlen(expected_old_key) + 1), false);
/* Version marker */
assert_int_equal(HasKeyDB(db, "version", strlen("version") + 1), true);
/* Incoming connection quality */
KeyHostSeen khs;
assert_int_equal(ReadDB(db, expected_quality_key, &khs, sizeof(khs)), true);
assert_int_equal(khs.lastseen, 666777);
assert_double_close(khs.Q.q, 12345.0);
assert_double_close(khs.Q.expect, 12345.0);
assert_double_close(khs.Q.var, 6543210.0);
/* Address mapping */
char address[CF_BUFSIZE];
assert_int_equal(ReadDB(db, KEYHASH_KEY, address, sizeof(address)), true);
assert_string_equal(address, "1.2.3.4");
/* Reverse mapping */
char keyhash[CF_BUFSIZE];
assert_int_equal(ReadDB(db, "a1.2.3.4", keyhash, sizeof(keyhash)), true);
assert_string_equal(keyhash, KEYHASH);
CloseDB(db);
}
void test_migrate_incoming(void)
{
test_migrate_single(KEYHASH_IN, QUALITY_IN);
}
/// write to preference table sql
void preferences::writeDB(){
OpenDB();
string str2;
stringstream os;
os << "INSERT INTO pref (usr, PASS, SERVER, PRT, SQLTABLE, SQL, PLAYLISTDIR) VALUES ('"
<< USER << "','" << PASS << "','" << SERVER << "','" << PORT << "','" << TABLE << "','" << DBlocation << "','" << PLAYLISTDIR << "')";
str2 = os.str();
// cout << str2 << endl;
writeMe(str2);
}
BOOL CBCGPODBCGridCtrl::OpenMSAccessFile (LPCTSTR lpszFileName,
LPCTSTR lpszUserName, LPCTSTR lpszPassword, LPARAM lOptions)
{
ASSERT(lpszFileName != NULL);
CString strConnect;
strConnect.Format (_T("DSN=MS Access Database;DBQ=%s"),
lpszFileName);
return OpenDB (strConnect, lpszUserName, lpszPassword, lOptions);
}
static void Mon_HistoryUpdate(time_t time, const Averages *newvals)
{
CF_DB *dbp;
if (!OpenDB(&dbp, dbid_history))
{
return;
}
PutRecordForTime(dbp, time, newvals);
CloseDB(dbp);
}
static void NotePerformance(char *eventname, time_t t, double value)
{
CF_DB *dbp;
Event e, newe;
double lastseen;
int lsea = SECONDS_PER_WEEK;
time_t now = time(NULL);
CfDebug("PerformanceEvent(%s,%.1f s)\n", eventname, value);
if (!OpenDB(&dbp, dbid_performance))
{
return;
}
if (ReadDB(dbp, eventname, &e, sizeof(e)))
{
lastseen = now - e.t;
newe.t = t;
newe.Q = QAverage(e.Q, value, 0.3);
/* Have to kickstart variance computation, assume 1% to start */
if (newe.Q.var <= 0.0009)
{
newe.Q.var = newe.Q.expect / 100.0;
}
}
else
{
lastseen = 0.0;
newe.t = t;
newe.Q.q = value;
newe.Q.dq = 0;
newe.Q.expect = value;
newe.Q.var = 0.001;
}
if (lastseen > (double) lsea)
{
CfDebug("Performance record %s expired\n", eventname);
DeleteDB(dbp, eventname);
}
else
{
CfOut(cf_verbose, "", "Performance(%s): time=%.4lf secs, av=%.4lf +/- %.4lf\n", eventname, value, newe.Q.expect,
sqrt(newe.Q.var));
WriteDB(dbp, eventname, &newe, sizeof(newe));
}
CloseDB(dbp);
}
static void Mon_DumpSlowlyVaryingObservations(void)
{
CF_DB *dbp;
CF_DBC *dbcp;
FILE *fout;
char *key;
void *stored;
int ksize, vsize;
char name[CF_BUFSIZE];
if (!OpenDB(&dbp, dbid_static))
{
return;
}
snprintf(name, CF_BUFSIZE - 1, "%s%cstate%cstatic_data", CFWORKDIR, FILE_SEPARATOR, FILE_SEPARATOR);
if ((fout = fopen(name, "w")) == NULL)
{
Log(LOG_LEVEL_ERR, "Unable to save discovery data in '%s'. (fopen: %s)", name, GetErrorStr());
CloseDB(dbp);
return;
}
/* Acquire a cursor for the database. */
if (!NewDBCursor(dbp, &dbcp))
{
Log(LOG_LEVEL_INFO, "Unable to scan class db");
CloseDB(dbp);
return;
}
while (NextDB(dbcp, &key, &ksize, &stored, &vsize))
{
char buf[CF_MAXVARSIZE], lval[CF_MAXVARSIZE], rval[CF_BUFSIZE];
strncpy(buf, key, CF_MAXVARSIZE - 1);
sscanf(buf, "%s:", lval);
if (stored != NULL)
{
strncpy(rval, stored, CF_BUFSIZE - 1);
fprintf(fout, "%s:%s\n", lval, rval);
}
}
DeleteDBCursor(dbcp);
CloseDB(dbp);
fclose(fout);
}
void EvalContextHeapPersistentRemove(const char *context)
{
CF_DB *dbp;
if (!OpenDB(&dbp, dbid_state))
{
return;
}
DeleteDB(dbp, context);
CfDebug("Deleted any persistent state %s\n", context);
CloseDB(dbp);
}
static void Mon_SaveFilePosition(char *name, long fileptr)
{
CF_DB *dbp;
if (!OpenDB(&dbp, dbid_static))
{
return;
}
Log(LOG_LEVEL_VERBOSE, "Saving state for %s at %ld", name, fileptr);
WriteDB(dbp, name, &fileptr, sizeof(long));
CloseDB(dbp);
}
void EvalContextHeapPersistentRemove(const char *context)
{
CF_DB *dbp;
if (!OpenDB(&dbp, dbid_state))
{
return;
}
DeleteDB(dbp, context);
Log(LOG_LEVEL_DEBUG, "Deleted persistent class '%s'", context);
CloseDB(dbp);
}
/// create database
void preferences::createDB() {
OpenDB();
string finalQry[7];
finalQry[0] = "create table Artists(key INTEGER PRIMARY KEY,Artist TEXT,ArtistID integer, ArtistPar integer) ";
finalQry[1] = "create table Albums(key INTEGER PRIMARY KEY,Album TEXT,AlbumID integer, AlbumPar integer)";
finalQry[2] = "create table Songs(key INTEGER PRIMARY KEY,Song TEXT,SongID integer, SongPar integer)";
finalQry[3] = "create table Videos(key INTEGER PRIMARY KEY,Video TEXT,VideoID integer, VideoPar integer)";
finalQry[4] = "create table VidDirs(key INTEGER PRIMARY KEY,VidDir TEXT,VidDirID integer, VidDirPar integer)";
finalQry[5] = "create table pref(key INTEGER PRIMARY KEY,usr TEXT,PASS TEXT,SERVER TEXT,PRT TEXT,SQLTABLE TEXT,SQL TEXT,PLAYLISTDIR TEXT)";
finalQry[6] = "create table radio(id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL DEFAULT (0),name TEXT NOT NULL,url TEXT NOT NULL)";
for(int i=0; i<7; i++){
writeMe(finalQry[i]);
}
}
static long Mon_RestoreFilePosition(char *name)
{
CF_DB *dbp;
long fileptr;
if (!OpenDB(&dbp, dbid_static))
{
return 0L;
}
ReadDB(dbp, name, &fileptr, sizeof(long));
Log(LOG_LEVEL_VERBOSE, "Resuming state for %s at %ld", name, fileptr);
CloseDB(dbp);
return fileptr;
}
void test_recreate(void **state)
{
/* Test that recreating database works properly */
char tcdb_db[CF_BUFSIZE];
snprintf(tcdb_db, CF_BUFSIZE, "%s/cf_classes.tcdb", CFWORKDIR);
CreateGarbage(tcdb_db);
char qdbm_db[CF_BUFSIZE];
snprintf(qdbm_db, CF_BUFSIZE, "%s/cf_classes.qdbm", CFWORKDIR);
CreateGarbage(qdbm_db);
CF_DB *db;
assert_int_equal(OpenDB(&db, dbid_classes), true);
CloseDB(db);
}
static void UpdateAverages(EvalContext *ctx, char *timekey, Averages newvals)
{
CF_DB *dbp;
if (!OpenDB(&dbp, dbid_observations))
{
return;
}
Log(LOG_LEVEL_INFO, "Updated averages at '%s'", timekey);
WriteDB(dbp, timekey, &newvals, sizeof(Averages));
WriteDB(dbp, "DATABASE_AGE", &AGE, sizeof(double));
CloseDB(dbp);
HistoryUpdate(ctx, newvals);
}
static void UpdateAverages(char *timekey, Averages newvals)
{
CF_DB *dbp;
if (!OpenDB(&dbp, dbid_observations))
{
return;
}
CfOut(cf_inform, "", "Updated averages at %s\n", timekey);
WriteDB(dbp, timekey, &newvals, sizeof(Averages));
WriteDB(dbp, "DATABASE_AGE", &AGE, sizeof(double));
CloseDB(dbp);
HistoryUpdate(newvals);
}
void UpdateLastSawHost(const char *hostkey, const char *address,
bool incoming, time_t timestamp)
{
DBHandle *db = NULL;
if (!OpenDB(&db, dbid_lastseen))
{
Log(LOG_LEVEL_ERR, "Unable to open last seen db");
return;
}
/* Update quality-of-connection entry */
char quality_key[CF_BUFSIZE];
snprintf(quality_key, CF_BUFSIZE, "q%c%s", incoming ? 'i' : 'o', hostkey);
KeyHostSeen newq = { .lastseen = timestamp };
KeyHostSeen q;
if (ReadDB(db, quality_key, &q, sizeof(q)))
{
newq.Q = QAverage(q.Q, newq.lastseen - q.lastseen, 0.4);
}
else
{
/* FIXME: more meaningful default value? */
newq.Q = QDefinite(0);
}
WriteDB(db, quality_key, &newq, sizeof(newq));
/* Update forward mapping */
char hostkey_key[CF_BUFSIZE];
snprintf(hostkey_key, CF_BUFSIZE, "k%s", hostkey);
WriteDB(db, hostkey_key, address, strlen(address) + 1);
/* Update reverse mapping */
char address_key[CF_BUFSIZE];
snprintf(address_key, CF_BUFSIZE, "a%s", address);
WriteDB(db, address_key, hostkey, strlen(hostkey) + 1);
CloseDB(db);
}
void *contend(void *param)
{
CF_DB *db;
if (!OpenDB(&db, DB_ID))
{
return (void *)STATUS_FAILED_OPEN;
}
DBWriteTestData(db);
TestReadWriteData(db);
TestCursorIteration(db);
CloseDB(db);
return (void *)STATUS_SUCCESS;
}
void test_ignore_wrong_sized(void)
{
/* Test that malformed values are discarded */
DBHandle *db = setup(true);
const char *value = "+";
assert_int_equal(WriteDB(db, "+++", value, 2), true);
CloseDB(db);
assert_int_equal(OpenDB(&db, dbid_lastseen), true);
assert_int_equal(HasKeyDB(db, "+++", 4), false);
assert_int_equal(HasKeyDB(db, "k++", 4), false);
assert_int_equal(HasKeyDB(db, "qi++", 5), false);
assert_int_equal(HasKeyDB(db, "qo++", 5), false);
assert_int_equal(HasKeyDB(db, "a+", 3), false);
CloseDB(db);
}
static void test_remove(void **context)
{
setup();
UpdateLastSawHost("SHA-12345", "127.0.0.64", true, 555);
UpdateLastSawHost("SHA-12345", "127.0.0.64", false, 556);
RemoveHostFromLastSeen("SHA-12345");
DBHandle *db;
OpenDB(&db, dbid_lastseen);
assert_int_equal(HasKeyDB(db, "qiSHA-12345", strlen("qiSHA-12345") + 1), false);
assert_int_equal(HasKeyDB(db, "qoSHA-12345", strlen("qoSHA-12345") + 1), false);
assert_int_equal(HasKeyDB(db, "kSHA-12345", strlen("kSHA-12345") + 1), false);
assert_int_equal(HasKeyDB(db, "a127.0.0.64", strlen("a127.0.0.64") + 1), false);
CloseDB(db);
}
