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);
}
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);
}
/* Funkcija ierakstu dzesanai */
int DelRec(void) {
unsigned short int inputId; // Lietotāja inputs
if(ReadDB() == EXIT_SUCCESS) { // Izvadam visus ierakstus
printline("Enter ID of book you want to delete:");
scanf("%hu",&inputId);
__fpurge(stdin);
{
int my_rec, v_yes_no;;
while(
//Ejam cauri visiem atrastajiem ierakstiem (bet vajadzētu būt tikai vienam)
(my_rec =
searchElement( offsetof( struct book_rec_type, id)
//, member_size( struct book_rec_type, id)
, (int*)&inputId,
UNSIGNED_SHORT_INT )
) >= 0) {
// Prasam vai dzēst ierakstu
v_yes_no = askForConfirmation();
if(v_yes_no == 1)
//Dzēšam ierakstu
if(removeRecord(my_rec) == EXIT_SUCCESS)
printline("The record has been successfully removed");
}
}
}
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;
}
bool AcquireLockByID(const char *lock_id, int acquire_after_minutes)
{
CF_DB *dbp = OpenLock();
if(dbp == NULL)
{
return false;
}
bool result;
LockData lock_data;
if (ReadDB(dbp, lock_id, &lock_data, sizeof(lock_data)))
{
if(lock_data.time + (acquire_after_minutes * SECONDS_PER_MINUTE) < time(NULL))
{
result = WriteLockDataCurrent(dbp, lock_id);
}
else
{
result = false;
}
}
else
{
result = WriteLockDataCurrent(dbp, lock_id);
}
CloseLock(dbp);
return result;
}
bool InvalidateLockTime(const char *lock_id)
{
time_t epoch = 0;
CF_DB *dbp = OpenLock();
if (dbp == NULL)
{
return false;
}
LockData lock_data;
if(!ReadDB(dbp, lock_id, &lock_data, sizeof(lock_data)))
{
CloseLock(dbp);
return true; /* nothing to invalidate */
}
lock_data.time = epoch;
bool result = WriteLockData(dbp, lock_id, &lock_data);
CloseLock(dbp);
return result;
}
BOOL CEquipmentLocationDialog::OnInitDialog()
{
CDialog::OnInitDialog();
// DWORD dwStyle =m_ctlCarsList.SendMessage(LVM_GETEXTENDEDLISTVIEWSTYLE,0,0);
// dwStyle |= LVS_EX_GRIDLINES;
// dwStyle |= LVS_EX_FULLROWSELECT;
// m_ctlCarsList.SendMessage(LVM_SETEXTENDEDLISTVIEWSTYLE, 0, dwStyle);
m_ctlCarsList.InsertColumn(0,"Car Number");
m_ctlCarsList.InsertColumn(1,"Reporting Marks");
m_ctlCarsList.InsertColumn(2,"Car Type");
m_ctlCarsList.InsertColumn(3,"E/L");
m_ctlCarsList.InsertColumn(4,"Last Movement");
m_ctlCarsList.InsertColumn(5,"Available on");
//
m_ctlCarsList.SetColumnWidth(0,LVSCW_AUTOSIZE_USEHEADER);
m_ctlCarsList.SetColumnWidth(1,LVSCW_AUTOSIZE_USEHEADER);
m_ctlCarsList.SetColumnWidth(2,85);
m_ctlCarsList.SetColumnWidth(3,LVSCW_AUTOSIZE_USEHEADER);
m_ctlCarsList.SetColumnWidth(4,LVSCW_AUTOSIZE_USEHEADER);
m_ctlCarsList.SetColumnWidth(5,LVSCW_AUTOSIZE_USEHEADER);
//m_ctlCarsList.SetColumnWidth(3,LVSCW_AUTOSIZE_USEHEADER);
//
ReadDB();
m_ctlCarsList.RestoreState("State","EquipmentLoocationDialog_m_ctlCarsList");
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
/**
* @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;
}
bool LastseenMigration(DBHandle *db)
{
char version[64];
if (ReadDB(db, "version", version, sizeof(version)) == false)
{
return LastseenMigrationVersion0(db);
}
return true;
}
static size_t DBVersion(DBHandle *db)
{
char version[64];
if (ReadDB(db, "version", version, sizeof(version)) == false)
{
return 0;
}
else
{
return StringToLong(version);
}
}
void CLocationDialog::OnDelbutton()
{
if( MessageBox("Deleting a Location may have adverse effects on sidings, industries, trains, and. Are you sure you want to do this?","Delete Location?",MB_YESNO) == IDNO )
return;
int iSel = m_ctlLocationList.GetSelectionMark();
int iID = m_ctlLocationList.GetItemData(iSel);
CppSQLite3DB* pDB = &((CTrainOpsApp*)AfxGetApp())->m_pDB;
CString sSQL;
sSQL.Format("DELETE FROM Locations WHERE id=%d;",iID);
pDB->execDML(sSQL);
ReadDB();
}
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);
}
BOOL CLocationDialog::OnInitDialog()
{
CDialog::OnInitDialog();
// TODO: Add extra initialization here
m_ctlLocationList.InsertColumn(0,"Location Name");
m_ctlLocationList.SetColumnWidth(0,275);
//m_ctlLocationList.ModifyStyle(0 ,LVS_EDITLABELS );
ReadDB();
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
static bool Address2HostkeyInDB(DBHandle *db, const char *address, char *result)
{
char address_key[CF_BUFSIZE];
char hostkey[CF_BUFSIZE];
/* Address key: "a" + address */
snprintf(address_key, CF_BUFSIZE, "a%s", address);
if (!ReadDB(db, address_key, &hostkey, sizeof(hostkey)))
{
return false;
}
char hostkey_key[CF_BUFSIZE];
char back_address[CF_BUFSIZE];
/* Hostkey key: "k" + hostkey */
snprintf(hostkey_key, CF_BUFSIZE, "k%s", hostkey);
if (!ReadDB(db, hostkey_key, &back_address, sizeof(back_address)))
{
/* There is no key -> address mapping. Remove reverse mapping and return failure. */
DeleteDB(db, address_key);
return false;
}
if (strcmp(address, back_address) != 0)
{
/* Forward and reverse mappings do not match. Remove reverse mapping and return failure. */
DeleteDB(db, address_key);
return false;
}
strlcpy(result, hostkey, CF_BUFSIZE);
return true;
}
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 CLocationDialog::OnAddbutton()
{
CLocationDetailDialog pDlg;
if( pDlg.DoModal() != IDOK )
return;
CString sLocationName = pDlg.GetLocationName();
m_ctlLocationList.InsertItem(m_ctlLocationList.GetItemCount(),sLocationName);
//
// insert into database
//
CppSQLite3DB* pDB = &((CTrainOpsApp*)AfxGetApp())->m_pDB;
CString sSQL;
sSQL.Format("INSERT INTO Locations (name) VALUES (\"%s\")",sLocationName);
pDB->execQuery(sSQL);
//
ReadDB();
}
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);
}
bool RemoveHostFromLastSeen(const char *hostkey)
{
DBHandle *db;
if (!OpenDB(&db, dbid_lastseen))
{
CfOut(cf_error, "", "Unable to open lastseen database");
return false;
}
/* Lookup corresponding address entry */
char hostkey_key[CF_BUFSIZE];
snprintf(hostkey_key, CF_BUFSIZE, "k%s", hostkey);
char address[CF_BUFSIZE];
if (ReadDB(db, hostkey_key, &address, sizeof(address)) == true)
{
/* Remove address entry */
char address_key[CF_BUFSIZE];
snprintf(address_key, CF_BUFSIZE, "a%s", address);
DeleteDB(db, address_key);
}
/* Remove quality-of-connection entries */
char quality_key[CF_BUFSIZE];
snprintf(quality_key, CF_BUFSIZE, "qi%s", hostkey);
DeleteDB(db, quality_key);
snprintf(quality_key, CF_BUFSIZE, "qo%s", hostkey);
DeleteDB(db, quality_key);
/* Remove main entry */
DeleteDB(db, hostkey_key);
CloseDB(db);
return true;
}
static pid_t FindLockPid(char *name)
{
CF_DB *dbp;
LockData entry;
if ((dbp = OpenLock()) == NULL)
{
return -1;
}
if (ReadDB(dbp, name, &entry, sizeof(entry)))
{
CloseLock(dbp);
return entry.pid;
}
else
{
CloseLock(dbp);
return -1;
}
}
static void test_update(void **context)
{
setup();
UpdateLastSawHost("SHA-12345", "127.0.0.64", true, 555);
UpdateLastSawHost("SHA-12345", "127.0.0.64", true, 1110);
DBHandle *db;
OpenDB(&db, dbid_lastseen);
KeyHostSeen q;
assert_int_equal(ReadDB(db, "qiSHA-12345", &q, sizeof(q)), true);
assert_int_equal(q.lastseen, 1110);
assert_double_close(q.Q.q, 555.0);
assert_double_close(q.Q.dq, 555.0);
assert_double_close(q.Q.expect, 222.0);
assert_double_close(q.Q.var, 123210.0);
CloseDB(db);
}
static void GetDatabaseAge()
{
CF_DB *dbp;
if (!OpenDB(&dbp, dbid_observations))
{
return;
}
if (ReadDB(dbp, "DATABASE_AGE", &AGE, sizeof(double)))
{
WAGE = AGE / SECONDS_PER_WEEK * CF_MEASURE_INTERVAL;
Log(LOG_LEVEL_DEBUG, "Previous DATABASE_AGE %f", AGE);
}
else
{
Log(LOG_LEVEL_DEBUG, "No previous DATABASE_AGE");
AGE = 0.0;
}
CloseDB(dbp);
}
static void test_up_to_date(void)
{
/* Test that upgrade is not performed if there is already a version
* marker */
DBHandle *db = setup(false);
assert_int_equal(WriteDB(db, "foo", &dummy_event, sizeof(dummy_event)), true);
CloseDB(db);
/* Test that manually inserted key still has unqalified name the next
time the DB is opened, which is an indicator of the DB not being
upgraded */
assert_int_equal(OpenDB(&db, dbid_bundles), true);
Event read_value;
assert_int_equal(ReadDB(db, "foo", &read_value, sizeof(read_value)), true);
assert_int_equal(read_value.t, 1);
CloseDB(db);
}
static void GetDatabaseAge()
{
CF_DB *dbp;
if (!OpenDB(&dbp, dbid_observations))
{
return;
}
if (ReadDB(dbp, "DATABASE_AGE", &AGE, sizeof(double)))
{
WAGE = AGE / SECONDS_PER_WEEK * CF_MEASURE_INTERVAL;
CfDebug("\n\nPrevious DATABASE_AGE %f\n\n", AGE);
}
else
{
CfDebug("No previous AGE\n");
AGE = 0.0;
}
CloseDB(dbp);
}
void CLocationDialog::OnDblclkLocationlist(NMHDR* pNMHDR, LRESULT* pResult)
{
// TODO: Add your control notification handler code here
int iSel = m_ctlLocationList.GetSelectionMark();
if( iSel >= 0 )
{
CLocationDetailDialog pDlg;
int iID = m_ctlLocationList.GetItemData(iSel);
// pDlg.SetLocationName(m_ctlLocationList.GetItemText(iSel,0));
if( pDlg.DoModal() != IDOK )
return;
CString sLocationName = pDlg.GetLocationName();
CppSQLite3DB* pDB = &((CTrainOpsApp*)AfxGetApp())->m_pDB;
CString sSQL;
sSQL.Format("update Locations set name=\"%s\" where id=%d",sLocationName,iID,0);
pDB->execQuery(sSQL);
//
ReadDB();
}
*pResult = 0;
}
void EvalContextHeapPersistentSave(const char *context, const char *ns, unsigned int ttl_minutes, ContextStatePolicy policy)
{
CF_DB *dbp;
CfState state;
time_t now = time(NULL);
char name[CF_BUFSIZE];
if (!OpenDB(&dbp, dbid_state))
{
return;
}
snprintf(name, CF_BUFSIZE, "%s%c%s", ns, CF_NS, context);
if (ReadDB(dbp, name, &state, sizeof(state)))
{
if (state.policy == CONTEXT_STATE_POLICY_PRESERVE)
{
if (now < state.expires)
{
CfOut(OUTPUT_LEVEL_VERBOSE, "", " -> Persisent state %s is already in a preserved state -- %jd minutes to go\n",
name, (intmax_t)((state.expires - now) / 60));
CloseDB(dbp);
return;
}
}
}
else
{
CfOut(OUTPUT_LEVEL_VERBOSE, "", " -> New persistent state %s\n", name);
}
state.expires = now + ttl_minutes * 60;
state.policy = policy;
WriteDB(dbp, name, &state, sizeof(state));
CloseDB(dbp);
}
void NovaNamedEvent(const char *eventname, double value)
{
Event ev_new, ev_old;
time_t now = time(NULL);
CF_DB *dbp;
if (!OpenDB(&dbp, dbid_measure))
{
return;
}
ev_new.t = now;
if (ReadDB(dbp, eventname, &ev_old, sizeof(ev_old)))
{
if (isnan(ev_old.Q.expect))
{
ev_old.Q.expect = value;
}
if (isnan(ev_old.Q.var))
{
ev_old.Q.var = 0;
}
ev_new.Q = QAverage(ev_old.Q, value, 0.7);
}
else
{
ev_new.Q = QDefinite(value);
}
Log(LOG_LEVEL_VERBOSE, "Wrote scalar named event \"%s\" = (%.2lf,%.2lf,%.2lf)", eventname, ev_new.Q.q,
ev_new.Q.expect, sqrt(ev_new.Q.var));
WriteDB(dbp, eventname, &ev_new, sizeof(ev_new));
CloseDB(dbp);
}
time_t FindLockTime(char *name)
{
CF_DB *dbp;
LockData entry;
CfDebug("FindLockTime(%s)\n", name);
if ((dbp = OpenLock()) == NULL)
{
return -1;
}
if (ReadDB(dbp, name, &entry, sizeof(entry)))
{
CloseLock(dbp);
return entry.time;
}
else
{
CloseLock(dbp);
return -1;
}
}
static void test_up_to_date(void)
{
/* Test that upgrade is not performed if there is already a version
* marker */
DBHandle *db = setup(false);
const char *value = "+";
assert_int_equal(WriteDB(db, "+++", value, 2), true);
CloseDB(db);
/* Test that manually inserted key which matches the format of old-style
* keys is still present next time database is open, which is an indicator
* of database not being upgraded */
assert_int_equal(OpenDB(&db, dbid_lastseen), true);
char read_value[CF_BUFSIZE];
assert_int_equal(ReadDB(db, "+++", &read_value, sizeof(read_value)), true);
assert_string_equal(read_value, "+");
CloseDB(db);
}
bool ScanLastSeenQuality(LastSeenQualityCallback callback, void *ctx)
{
DBHandle *db;
DBCursor *cursor;
if (!OpenDB(&db, dbid_lastseen))
{
Log(LOG_LEVEL_ERR, "Unable to open lastseen database");
return false;
}
if (!NewDBCursor(db, &cursor))
{
Log(LOG_LEVEL_ERR, "Unable to create lastseen database cursor");
CloseDB(db);
return false;
}
char *key;
void *value;
int ksize, vsize;
while (NextDB(cursor, &key, &ksize, &value, &vsize))
{
/* Only look for "keyhost" entries */
if (key[0] != 'k')
{
continue;
}
const char *hostkey = key + 1;
const char *address = value;
char incoming_key[CF_BUFSIZE];
snprintf(incoming_key, CF_BUFSIZE, "qi%s", hostkey);
KeyHostSeen incoming;
if (ReadDB(db, incoming_key, &incoming, sizeof(incoming)))
{
if (!(*callback)(hostkey, address, true, &incoming, ctx))
{
break;
}
}
char outgoing_key[CF_BUFSIZE];
snprintf(outgoing_key, CF_BUFSIZE, "qo%s", hostkey);
KeyHostSeen outgoing;
if (ReadDB(db, outgoing_key, &outgoing, sizeof(outgoing)))
{
if (!(*callback)(hostkey, address, false, &outgoing, ctx))
{
break;
}
}
}
DeleteDBCursor(cursor);
CloseDB(db);
return true;
}
/**
* @brief check whether the lastseen DB is coherent or not
*
* A DB is coherent mainly if all the entries are valid and if there is
* a strict one-to-one correspondance between hosts and key digests
* (whether in MD5 or SHA1 format).
*
* @retval true if the lastseen DB is coherent, false otherwise
*/
bool IsLastSeenCoherent(void)
{
DBHandle *db;
DBCursor *cursor;
bool res = true;
if (!OpenDB(&db, dbid_lastseen))
{
Log(LOG_LEVEL_ERR, "Unable to open lastseen database");
return false;
}
if (!NewDBCursor(db, &cursor))
{
Log(LOG_LEVEL_ERR, "Unable to create lastseen database cursor");
CloseDB(db);
return false;
}
char *key;
void *value;
int ksize, vsize;
Item *qkeys=NULL;
Item *akeys=NULL;
Item *kkeys=NULL;
Item *ahosts=NULL;
Item *khosts=NULL;
char val[CF_BUFSIZE];
while (NextDB(cursor, &key, &ksize, &value, &vsize))
{
if (key[0] != 'k' && key[0] != 'q' && key[0] != 'a' )
{
continue;
}
if (key[0] == 'q' )
{
if (strncmp(key,"qiSHA=",5)==0 || strncmp(key,"qoSHA=",5)==0 ||
strncmp(key,"qiMD5=",5)==0 || strncmp(key,"qoMD5=",5)==0)
{
if (IsItemIn(qkeys, key+2)==false)
{
PrependItem(&qkeys, key+2, NULL);
}
}
}
if (key[0] == 'k' )
{
if (strncmp(key, "kSHA=", 4)==0 || strncmp(key, "kMD5=", 4)==0)
{
if (IsItemIn(kkeys, key+1)==false)
{
PrependItem(&kkeys, key+1, NULL);
}
if (ReadDB(db, key, &val, vsize))
{
if (IsItemIn(khosts, val)==false)
{
PrependItem(&khosts, val, NULL);
}
}
}
}
if (key[0] == 'a' )
{
if (IsItemIn(ahosts, key+1)==false)
{
PrependItem(&ahosts, key+1, NULL);
}
if (ReadDB(db, key, &val, vsize))
{
if (IsItemIn(akeys, val)==false)
{
PrependItem(&akeys, val, NULL);
}
}
}
}
DeleteDBCursor(cursor);
CloseDB(db);
if (ListsCompare(ahosts, khosts) == false)
{
res = false;
goto clean;
}
if (ListsCompare(akeys, kkeys) == false)
{
res = false;
goto clean;
}
clean:
DeleteItemList(qkeys);
DeleteItemList(akeys);
DeleteItemList(kkeys);
DeleteItemList(ahosts);
DeleteItemList(khosts);
return res;
}
