void
dumpstream(XDRInputFileStream& in)
{
T tmp;
while (in && in.readOne(tmp))
{
std::cout << xdr::xdr_to_string(tmp) << std::endl;
}
}
InputIterator(std::shared_ptr<Bucket const> bucket)
: mBucket(bucket), mEntryPtr(nullptr)
{
if (!mBucket->mFilename.empty())
{
CLOG(TRACE, "Bucket")
<< "Bucket::InputIterator opening file to read: "
<< mBucket->mFilename;
mIn.open(mBucket->mFilename);
loadEntry();
}
}
void
loadEntry()
{
if (mIn.readOne(mEntry))
{
mEntryPtr = &mEntry;
}
else
{
mEntryPtr = nullptr;
}
}
void
Bucket::apply(Database& db) const
{
if (getFilename().empty())
{
return;
}
BucketEntry entry;
XDRInputFileStream in;
in.open(getFilename());
size_t i = 0;
db.getSession().begin();
while (in && in.readOne(entry))
{
LedgerHeader
lh; // buckets, by definition are independent from the header
LedgerDelta delta(lh, db, false);
if ((i++ & 0xfff) == 0xfff)
{
db.clearPreparedStatementCache();
db.getSession().commit();
CLOG(INFO, "Bucket") << "Bucket-apply: committed " << i
<< " entries";
db.getSession().begin();
}
if (entry.type() == LIVEENTRY)
{
EntryFrame::pointer ep = EntryFrame::FromXDR(entry.liveEntry());
ep->storeAddOrChange(delta, db);
}
else
{
EntryFrame::storeDelete(delta, db, entry.deadEntry());
}
// No-op, just to avoid needless rollback.
delta.commit();
}
db.getSession().commit();
}
void
dumpXdrStream(std::string const& filename)
{
std::regex rx(
".*(ledger|bucket|transactions|results|scp)-[[:xdigit:]]+\\.xdr");
std::smatch sm;
if (std::regex_match(filename, sm, rx))
{
XDRInputFileStream in;
in.open(filename);
if (sm[1] == "ledger")
{
dumpstream<LedgerHeaderHistoryEntry>(in);
}
else if (sm[1] == "bucket")
{
dumpstream<BucketEntry>(in);
}
else if (sm[1] == "transactions")
{
dumpstream<TransactionHistoryEntry>(in);
}
else if (sm[1] == "results")
{
dumpstream<TransactionHistoryResultEntry>(in);
}
else
{
assert(sm[1] == "scp");
dumpstream<SCPHistoryEntry>(in);
}
}
else
{
throw std::runtime_error("unrecognized XDR filename");
}
}
bool
tryRead(XDRInputFileStream& in, StellarMessage& m)
{
try
{
return in.readOne(m);
}
catch (xdr::xdr_runtime_error& e)
{
LOG(INFO) << "Caught XDR error '" << e.what()
<< "' on input substituting HELLO";
m.type(HELLO);
return true;
}
}
void
fuzz(std::string const& filename, el::Level logLevel,
std::vector<std::string> const& metrics)
{
Logging::setFmt("<fuzz>", false);
Logging::setLogLevel(logLevel, nullptr);
LOG(INFO) << "Fuzzing stellar-core " << STELLAR_CORE_VERSION;
LOG(INFO) << "Fuzz input is in " << filename;
Config cfg1, cfg2;
cfg1.RUN_STANDALONE = true;
cfg1.ARTIFICIALLY_ACCELERATE_TIME_FOR_TESTING = true;
cfg1.LOG_FILE_PATH = "fuzz-app-1.log";
cfg1.TMP_DIR_PATH = "fuzz-tmp-1";
cfg1.BUCKET_DIR_PATH = "fuzz-buckets-1";
cfg2.RUN_STANDALONE = true;
cfg2.ARTIFICIALLY_ACCELERATE_TIME_FOR_TESTING = true;
cfg1.LOG_FILE_PATH = "fuzz-app-2.log";
cfg2.TMP_DIR_PATH = "fuzz-tmp-2";
cfg2.BUCKET_DIR_PATH = "fuzz-buckets-2";
CfgDirGuard g1(cfg1);
CfgDirGuard g2(cfg2);
restart:
{
VirtualClock clock;
Application::pointer app1 = Application::create(clock, cfg1);
Application::pointer app2 = Application::create(clock, cfg2);
LoopbackPeerConnection loop(*app1, *app2);
while (clock.crank(false) > 0)
;
XDRInputFileStream in;
in.open(filename);
StellarMessage msg;
size_t i = 0;
while (tryRead(in, msg))
{
++i;
if (msg.type() != HELLO)
{
LOG(INFO) << "Fuzzer injecting message " << i << ": "
<< msgSummary(msg);
loop.getAcceptor()->Peer::sendMessage(msg);
}
size_t iter = 20;
while (clock.crank(false) > 0 && iter-- > 0)
;
}
}
if (getenv("AFL_PERSISTENT") && persist_cnt++ < PERSIST_MAX)
{
#ifndef _WIN32
raise(SIGSTOP);
#endif
goto restart;
}
}
BasicWork::State
FetchRecentQsetsWork::doWork()
{
// Phase 1: fetch remote history archive state
if (!mGetHistoryArchiveStateWork)
{
mGetHistoryArchiveStateWork =
addWork<GetHistoryArchiveStateWork>(mRemoteState, 0);
return State::WORK_RUNNING;
}
else if (mGetHistoryArchiveStateWork->getState() != State::WORK_SUCCESS)
{
return mGetHistoryArchiveStateWork->getState();
}
// Phase 2: download some SCP messages; for now we just pull the past
// 100 checkpoints = 9 hours of history. A more sophisticated view
// would survey longer time periods at lower resolution.
uint32_t numCheckpoints = 100;
uint32_t step = mApp.getHistoryManager().getCheckpointFrequency();
uint32_t window = numCheckpoints * step;
uint32_t lastSeq = mRemoteState.currentLedger;
uint32_t firstSeq = lastSeq < window ? (step - 1) : (lastSeq - window);
if (!mDownloadSCPMessagesWork)
{
CLOG(INFO, "History") << "Downloading recent SCP messages: ["
<< firstSeq << ", " << lastSeq << "]";
auto range = CheckpointRange{firstSeq, lastSeq, step};
mDownloadSCPMessagesWork = addWork<BatchDownloadWork>(
range, HISTORY_FILE_TYPE_SCP, *mDownloadDir);
return State::WORK_RUNNING;
}
else if (mDownloadSCPMessagesWork->getState() != State::WORK_SUCCESS)
{
return mDownloadSCPMessagesWork->getState();
}
// Phase 3: extract the qsets.
for (uint32_t i = firstSeq; i <= lastSeq; i += step)
{
CLOG(INFO, "History") << "Scanning for QSets in checkpoint: " << i;
XDRInputFileStream in;
FileTransferInfo fi(*mDownloadDir, HISTORY_FILE_TYPE_SCP, i);
try
{
in.open(fi.localPath_nogz());
}
catch (FileSystemException&)
{
CLOG(ERROR, "History") << POSSIBLY_CORRUPTED_LOCAL_FS;
return State::WORK_FAILURE;
}
SCPHistoryEntry tmp;
while (in && in.readOne(tmp))
{
mInferredQuorum.noteSCPHistory(tmp);
}
}
return State::WORK_SUCCESS;
}
~InputIterator()
{
mIn.close();
}
