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); }