int IndexDbLevelDb::addFilesToFileList(leveldb::DB* db)
{
char buf[1024];
int startId = 0;
string valStr;
string keyFileCount = "file_count";
int rv = dbRead(valStr, db, keyFileCount);
if(rv < 0) {
// key not found
dbWrite(db, keyFileCount, "1");
startId = 0;
}
else if(rv == 0) {
char* errp = NULL;
startId = strtol(valStr.c_str(), &errp, 16);
assert(*errp == '\0');
}
else {
printf("ERROR: db info\n");
}
int id = startId;
for(const auto& itr : m_fileContextMap) {
string fn = itr.first;
string key = TABLE_NAME_FILE_LIST "|" + fn;
int rv = dbRead(valStr, db, key);
string fid;
if(rv < 0) {
snprintf(buf, sizeof(buf), "%x", id);
fid = string(buf);
dbWrite(db, key, m_compileUnitId + "," + fid);
id++;
dbWrite(db, TABLE_NAME_GLOBAL_FILE_ID_TO_CU_ID "|" + fid, m_compileUnitId);
}
else {
// get fid
size_t pos = valStr.find(",");
assert(pos != string::npos);
fid = valStr.substr(pos+1, valStr.size()-1);
}
m_fileContextMap[fn].m_dbId = fid;
if(fn == m_compileUnit) {
m_cuDbId = fid;
}
}
snprintf(buf, sizeof(buf), "%x", id);
dbWrite(db, keyFileCount, buf);
return 0;
}
bool CTxWPool::Init(){
tgroup = NULL;
if(!dbRead()){
dbWrite();
}
return true;
}
TEST(DConcurrency, DBLockTakesX) {
LockerImpl ls;
Lock::DBLock dbWrite(&ls, "db", MODE_X);
const ResourceId resIdDb(RESOURCE_DATABASE, string("db"));
ASSERT(ls.getLockMode(resIdDb) == MODE_X);
}
void TestKeePass2Format::testXmlInvalidXmlChars()
{
QScopedPointer<Database> dbWrite(new Database());
QString strPlainInvalid =
QString().append(QChar(0x02)).append(QChar(0x19)).append(QChar(0xFFFE)).append(QChar(0xFFFF));
QString strPlainValid = QString()
.append(QChar(0x09))
.append(QChar(0x0A))
.append(QChar(0x20))
.append(QChar(0xD7FF))
.append(QChar(0xE000))
.append(QChar(0xFFFD));
// U+10437 in UTF-16: D801 DC37
// high low surrogate
QString strSingleHighSurrogate1 = QString().append(QChar(0xD801));
QString strSingleHighSurrogate2 = QString().append(QChar(0x31)).append(QChar(0xD801)).append(QChar(0x32));
QString strHighHighSurrogate = QString().append(QChar(0xD801)).append(QChar(0xD801));
QString strSingleLowSurrogate1 = QString().append(QChar(0xDC37));
QString strSingleLowSurrogate2 = QString().append(QChar((0x31))).append(QChar(0xDC37)).append(QChar(0x32));
QString strLowLowSurrogate = QString().append(QChar(0xDC37)).append(QChar(0xDC37));
QString strSurrogateValid1 = QString().append(QChar(0xD801)).append(QChar(0xDC37));
QString strSurrogateValid2 =
QString().append(QChar(0x31)).append(QChar(0xD801)).append(QChar(0xDC37)).append(QChar(0x32));
auto entry = new Entry();
entry->setUuid(QUuid::createUuid());
entry->setGroup(dbWrite->rootGroup());
entry->attributes()->set("PlainInvalid", strPlainInvalid);
entry->attributes()->set("PlainValid", strPlainValid);
entry->attributes()->set("SingleHighSurrogate1", strSingleHighSurrogate1);
entry->attributes()->set("SingleHighSurrogate2", strSingleHighSurrogate2);
entry->attributes()->set("HighHighSurrogate", strHighHighSurrogate);
entry->attributes()->set("SingleLowSurrogate1", strSingleLowSurrogate1);
entry->attributes()->set("SingleLowSurrogate2", strSingleLowSurrogate2);
entry->attributes()->set("LowLowSurrogate", strLowLowSurrogate);
entry->attributes()->set("SurrogateValid1", strSurrogateValid1);
entry->attributes()->set("SurrogateValid2", strSurrogateValid2);
QBuffer buffer;
buffer.open(QIODevice::ReadWrite);
bool hasError;
QString errorString;
writeXml(&buffer, dbWrite.data(), hasError, errorString);
QVERIFY(!hasError);
buffer.seek(0);
auto dbRead = readXml(&buffer, true, hasError, errorString);
if (hasError) {
qWarning("Database read error: %s", qPrintable(errorString));
}
QVERIFY(!hasError);
QVERIFY(dbRead.data());
QCOMPARE(dbRead->rootGroup()->entries().size(), 1);
Entry* entryRead = dbRead->rootGroup()->entries().at(0);
EntryAttributes* attrRead = entryRead->attributes();
QCOMPARE(attrRead->value("PlainInvalid"), QString());
QCOMPARE(attrRead->value("PlainValid"), strPlainValid);
QCOMPARE(attrRead->value("SingleHighSurrogate1"), QString());
QCOMPARE(attrRead->value("SingleHighSurrogate2"), QString("12"));
QCOMPARE(attrRead->value("HighHighSurrogate"), QString());
QCOMPARE(attrRead->value("SingleLowSurrogate1"), QString());
QCOMPARE(attrRead->value("SingleLowSurrogate2"), QString("12"));
QCOMPARE(attrRead->value("LowLowSurrogate"), QString());
QCOMPARE(attrRead->value("SurrogateValid1"), strSurrogateValid1);
QCOMPARE(attrRead->value("SurrogateValid2"), strSurrogateValid2);
}
int IndexDbLevelDb::initialize(const string& out_dir, const string& src_file_name, const string& excludeList, bool isRebuild, const char* curDir, int argc, const char** argv)
{
leveldb::DB* dbCommon = NULL;
m_defaultOptions.create_if_missing = true;
//m_defaultOptions.compression = leveldb::kNoCompression;
m_defaultOptions.compression = leveldb::kSnappyCompression;
m_defaultOptions.block_cache = leveldb::NewLRUCache(128 * 1024 * 1024);
m_defaultOptions.filter_policy = leveldb::NewBloomFilterPolicy(10);
const char* cwd = getcwd(m_CharBuff0, sizeof(m_CharBuff0));
assert(cwd != 0);
m_currentDirectory = m_CharBuff0;
// build options
snprintf(m_CharBuff0, sizeof(m_CharBuff0), "%d", isRebuild);
m_buildOpt = string(curDir) + "|" + excludeList + "|" + m_CharBuff0 + "|";
for(int i = 0; i < argc; i++) {
m_buildOpt += " " + string(argv[i]);
}
m_dbDir = out_dir;
m_compileUnit = src_file_name;
#ifdef TIMER
m_timers = new boost::timer::cpu_timer[k_timerNum];
for(int i = 0; i < k_timerNum; i++) {
m_timers[i].stop();
}
#endif
if(makeDirectory(m_dbDir.c_str())) {
return -1;
}
//
// update file list
//
leveldb::Status status;
m_commonDbDir = out_dir + "/common";
if (dbTryOpen(dbCommon, m_commonDbDir) < 0) {
fprintf(stderr, "Open fail.: %s\n", m_commonDbDir.c_str());
return -1;
}
assert(dbCommon != NULL);
string value;
string keyFile = m_compileUnit;
int rv = 0;
// check if already registered
rv = dbRead(value, dbCommon, TABLE_NAME_CU_NAME_TO_ID "|" + m_compileUnit);
if(rv < 0) {
// not found
// add file
string keyFileCount = "compile_unit_count";
rv = dbRead(value, dbCommon, keyFileCount);
if(rv < 0) {
// key not found
dbWrite(dbCommon, keyFileCount, "1");
m_compileUnitId = "0";
}
else if(rv == 0) {
char buf[1024];
m_compileUnitId = value;
char* errp = NULL;
int id = strtol(m_compileUnitId.c_str(), &errp, 16);
assert(*errp == '\0');
snprintf(buf, sizeof(buf), "%x", id+1);
dbWrite(dbCommon, keyFileCount, buf);
}
else {
printf("ERROR: db info\n");
}
dbWrite(dbCommon, TABLE_NAME_CU_NAME_TO_ID "|" + m_compileUnit, m_compileUnitId);
}
else if(rv == 0) {
// alread exists
m_compileUnitId = value;
}
dbClose(dbCommon);
// open database for this compile unit
assert(!m_compileUnitId.empty());
// list of files already processed
if(!isRebuild) {
leveldb::WriteBatch wb_common;
leveldb::DB* db_common;
int rv = dbTryOpen(db_common, m_commonDbDir);
if(rv < 0) {
printf("ERROR: common db open: %s\n", m_commonDbDir.c_str());
return -1;
}
leveldb::Iterator* it = db_common->NewIterator(leveldb::ReadOptions());
for (it->SeekToFirst(); it->Valid(); it->Next()) {
//cout << it->key().ToString() << ": " << it->value().ToString() << endl;
const string& key = it->key().ToString();
if(key.find(TABLE_NAME_FILE_LIST "|") == 0) {
m_finishedFiles[key.substr(2)] = it->value().ToString();
//cout << key.substr(2) << endl;
}
}
dbClose(db_common);
}
else {
m_isRebuild = true;
}
return 0;
}
