CVarRef SharedMap::get(const StringData* k, bool error /* = false */) const {
int index = getIndex(k);
if (index == -1) {
return error ? getNotFound(k) : null_variant;
}
return getValueRef(index);
}
CVarRef SharedMap::get(int64 k, bool error /* = false */) const {
int index = m_arr->getIndex(k);
if (index == -1) {
return error ? getNotFound(k) : null_variant;
}
return getValueRef(index);
}
TypedValue* APCLocalArray::NvGetStr(const ArrayData* ad,
const StringData* key) {
auto a = asSharedArray(ad);
auto index = a->getIndex(key);
if (index == -1) return nullptr;
return (TypedValue*)&a->getValueRef(index);
}
TypedValue* SharedMap::nvGetCell(int64 k, bool error) const {
int index = m_arr->getIndex(k);
if (index != -1) {
return getValueRef(index).getTypedAccessor();
}
return error ? nvGetNotFound(k) : NULL;
}
TypedValue* SharedMap::nvGetCell(const StringData* key, bool error) const {
StrNR k(key);
int index = m_arr->getIndex(k);
if (index != -1) {
return getValueRef(index).getTypedAccessor();
}
return error ? nvGetNotFound(key) : NULL;
}
ArrayData* APCLocalArray::loadElems() const {
auto count = m_arr->size();
ArrayData* elems;
if (m_arr->isPacked()) {
PackedArrayInit ai(count);
for (uint i = 0; i < count; i++) {
ai.append(getValueRef(i));
}
elems = ai.create();
} else {
ArrayInit ai(count);
for (uint i = 0; i < count; i++) {
ai.add(getKey(i), getValueRef(i), true);
}
elems = ai.create();
}
if (elems->isStatic()) {
elems = elems->copy();
}
return elems;
}
ArrayData* SharedMap::loadElems(bool mapInit /* = false */) const {
uint count = size();
bool isVec = isVector();
auto ai =
mapInit ? ArrayInit(count, ArrayInit::mapInit) :
isVec ? ArrayInit(count, ArrayInit::vectorInit) :
ArrayInit(count);
if (isVec) {
for (uint i = 0; i < count; i++) {
ai.set(getValueRef(i));
}
} else {
for (uint i = 0; i < count; i++) {
ai.add(m_map->getKey(i), getValueRef(i),
true);
}
}
ArrayData* elems = ai.create();
if (elems->isStatic()) elems = elems->copy();
return elems;
}
void BlockchainScanner::preloadUtxos()
{
LMDBEnv::Transaction tx;
db_->beginDBTransaction(&tx, STXO, LMDB::ReadOnly);
auto dbIter = db_->getIterator(STXO);
dbIter.seekToFirst();
while (dbIter.advanceAndRead())
{
StoredTxOut stxo;
stxo.unserializeDBKey(dbIter.getKeyRef());
stxo.unserializeDBValue(dbIter.getValueRef());
if (stxo.spentness_ == TXOUT_SPENT)
continue;
stxo.parentHash_ = move(db_->getTxHashForLdbKey(
stxo.getDBKeyOfParentTx(false)));
auto& idMap = utxoMap_[stxo.parentHash_];
idMap.insert(make_pair(stxo.txOutIndex_, move(stxo)));
}
}
TypedValue* SharedMap::nvGet(const StringData* key) const {
int index = m_arr->getIndex(key);
if (index == -1) return NULL;
return (TypedValue*)&getValueRef(index);
}
TypedValue* SharedMap::nvGet(int64 k) const {
int index = m_arr->getIndex(k);
if (index == -1) return NULL;
return (TypedValue*)&getValueRef(index);
}
CVarRef ArrayData::endRef() {
if (m_pos >= 0 && m_pos < size()) {
return getValueRef(size() - 1);
}
throw FatalErrorException("invalid ArrayData::m_pos");
}
void BlockchainScanner::updateSSH()
{
//loop over all subssh entiers in SUBSSH db,
//compile balance, txio count and summary map for each address
{
StoredDBInfo sdbi;
db_->getStoredDBInfo(SSH, sdbi);
BlockHeader* sdbiblock = nullptr;
try
{
sdbiblock = &blockchain_->getHeaderByHash(sdbi.topScannedBlkHash_);
}
catch (...)
{
sdbiblock = &blockchain_->getHeaderByHeight(0);
}
if (sdbiblock->isMainBranch())
{
if (sdbi.topBlkHgt_ != 0 &&
sdbi.topBlkHgt_ >= blockchain_->top().getBlockHeight())
{
LOGINFO << "no SSH to scan";
return;
}
}
}
map<BinaryData, StoredScriptHistory> sshMap_;
{
StoredScriptHistory* sshPtr = nullptr;
LMDBEnv::Transaction historyTx, sshTx;
db_->beginDBTransaction(&historyTx, SSH, LMDB::ReadOnly);
db_->beginDBTransaction(&sshTx, SUBSSH, LMDB::ReadOnly);
auto sshIter = db_->getIterator(SUBSSH);
sshIter.seekToFirst();
while (sshIter.advanceAndRead())
{
while (sshIter.isValid())
{
if (sshPtr != nullptr &&
sshIter.getKeyRef().contains(sshPtr->uniqueKey_))
break;
//new address
auto&& subsshkey = sshIter.getKey();
auto sshKey = subsshkey.getSliceRef(1, subsshkey.getSize() - 5);
sshPtr = &sshMap_[sshKey];
if (!scrAddrFilter_->hasScrAddress(sshKey))
{
LOGWARN << "invalid scrAddr in SUBSSH db";
continue;
}
//get what's already in the db
db_->getStoredScriptHistorySummary(*sshPtr, sshKey);
if (sshPtr->isInitialized())
{
//set iterator at unscanned height
auto hgtx = sshIter.getKeyRef().getSliceRef(-4, 4);
auto height = DBUtils::hgtxToHeight(hgtx);
if (sshPtr->alreadyScannedUpToBlk_ >= height)
{
//this ssh has already been scanned beyond the height sshIter is at,
//let's set the iterator to the correct height (or the next key)
auto&& newKey = sshIter.getKey().getSliceCopy(0, subsshkey.getSize() - 4);
auto&& newHgtx = DBUtils::heightAndDupToHgtx(
sshPtr->alreadyScannedUpToBlk_ + 1, 0);
newKey.append(newHgtx);
sshIter.seekTo(newKey);
continue;
}
}
else
{
sshPtr->uniqueKey_ = sshKey;
break;
}
}
//sanity check
if (!sshIter.isValid())
break;
//deser subssh
StoredSubHistory subssh;
subssh.unserializeDBKey(sshIter.getKeyRef());
//check dupID
if (db_->getValidDupIDForHeight(subssh.height_) != subssh.dupID_)
continue;
subssh.unserializeDBValue(sshIter.getValueRef());
for (auto& txioPair : subssh.txioMap_)
{
if (!txioPair.second.isMultisig())
{
//add up balance
if (txioPair.second.hasTxIn())
{
//check for same block fund&spend
auto&& keyOfOutput = txioPair.second.getDBKeyOfOutput();
auto&& keyOfInput = txioPair.second.getDBKeyOfInput();
if (keyOfOutput.startsWith(keyOfInput.getSliceRef(0, 4)))
{
//both output and input are part of the same block, skip
continue;
}
sshPtr->totalUnspent_ -= txioPair.second.getValue();
}
else
{
sshPtr->totalUnspent_ += txioPair.second.getValue();
}
}
}
//txio count
sshPtr->totalTxioCount_ += subssh.txioCount_;
//build subssh summary
sshPtr->subsshSummary_[subssh.height_] = subssh.txioCount_;
}
}
//write it
auto& topheader = blockchain_->getHeaderByHash(topScannedBlockHash_);
auto topheight = topheader.getBlockHeight();
LMDBEnv::Transaction putsshtx;
db_->beginDBTransaction(&putsshtx, SSH, LMDB::ReadWrite);
auto& scrAddrMap = scrAddrFilter_->getScrAddrMap();
for (auto& scrAddr : scrAddrMap)
{
auto& ssh = sshMap_[scrAddr.first];
if (!ssh.isInitialized())
{
ssh.uniqueKey_ = scrAddr.first;
}
BinaryData&& sshKey = ssh.getDBKey();
ssh.alreadyScannedUpToBlk_ = topheight;
BinaryWriter bw;
ssh.serializeDBValue(bw, ARMORY_DB_BARE, DB_PRUNE_NONE);
db_->putValue(SSH, sshKey.getRef(), bw.getDataRef());
}
//update sdbi
StoredDBInfo sdbi;
db_->getStoredDBInfo(SSH, sdbi);
sdbi.topScannedBlkHash_ = topScannedBlockHash_;
sdbi.topBlkHgt_ = topheight;
db_->putStoredDBInfo(SSH, sdbi);
}
void _xml_characterDataHandler(void *userData, const XML_Char *s, int len) {
XmlParser *parser = (XmlParser *)userData;
if (parser) {
Variant retval;
Array args = Array::Create();
if (parser->characterDataHandler.toBoolean()) {
args.append(parser);
args.append(_xml_xmlchar_zval(s, len, parser->target_encoding));
xml_call_handler(parser, parser->characterDataHandler, args);
}
if (!parser->data.isNull()) {
int i;
int doprint = 0;
char *decoded_value;
int decoded_len;
decoded_value = xml_utf8_decode(s,len,&decoded_len,
parser->target_encoding);
for (i = 0; i < decoded_len; i++) {
switch (decoded_value[i]) {
case ' ':
case '\t':
case '\n':
continue;
default:
doprint = 1;
break;
}
if (doprint) {
break;
}
}
if (doprint || (! parser->skipwhite)) {
if (parser->lastwasopen) {
String myval;
// check if value exists, if yes append to that
if (parser->ctag.toArrRef().exists(s_value)) {
myval = parser->ctag.toArray().rvalAt(s_value).toString();
myval += String(decoded_value, decoded_len, AttachString);
parser->ctag.toArrRef().set(s_value, myval);
} else {
parser->ctag.toArrRef().set(
s_value,
String(decoded_value,decoded_len,AttachString)
);
}
} else {
Array tag;
Variant curtag;
String myval;
String mytype;
auto const dataArr = parser->data.getArrayData();
curtag.assignRef(dataArr->getValueRef(dataArr->iter_end()));
if (curtag.toArrRef().exists(s_type)) {
mytype = curtag.toArrRef().rvalAt(s_type).toString();
if (!strcmp(mytype.data(), "cdata") &&
curtag.toArrRef().exists(s_value)) {
myval = curtag.toArrRef().rvalAt(s_value).toString();
myval += String(decoded_value, decoded_len, AttachString);
curtag.toArrRef().set(s_value, myval);
return;
}
}
if (parser->level <= XML_MAXLEVEL) {
tag = Array::Create();
_xml_add_to_info(parser, parser->ltags[parser->level-1] +
parser->toffset);
tag.set(s_tag, String(parser->ltags[parser->level-1] +
parser->toffset, CopyString));
tag.set(s_value, String(decoded_value, AttachString));
tag.set(s_type, s_cdata);
tag.set(s_level, parser->level);
parser->data.toArrRef().append(tag);
} else if (parser->level == (XML_MAXLEVEL + 1)) {
raise_warning("Maximum depth exceeded - Results truncated");
}
}
} else {
free(decoded_value);
}
}
}
}
TypedValue* APCLocalArray::NvGetInt(const ArrayData* ad, int64_t k) {
auto a = asSharedArray(ad);
auto index = a->getIndex(k);
if (index == -1) return nullptr;
return (TypedValue*)&a->getValueRef(index);
}
TypedValue* SharedMap::nvGet(const StringData* key) const {
int index = getIndex(key);
if (index == -1) return nullptr;
return (TypedValue*)&getValueRef(index);
}
CVarRef NameValueTableWrapper::currentRef() {
if (m_pos != ArrayData::invalid_index) {
return getValueRef(m_pos);
}
throw FatalErrorException("invalid ArrayData::m_pos");
}
TypedValue* SharedMap::nvGetCell(int64 k) const {
int index = m_arr->getIndex(k);
return index != -1 ? getValueRef(index).getTypedAccessor() :
nvGetNotFound(k);
}
CVarRef ArrayData::endRef() {
if (m_pos != invalid_index) {
return getValueRef(iter_end());
}
throw FatalErrorException("invalid ArrayData::m_pos");
}
CVarRef ArrayData::currentRef() {
if (size_t(m_pos) < size_t(size())) {
return getValueRef(m_pos);
}
throw FatalErrorException("invalid ArrayData::m_pos");
}
TypedValue* SharedMap::nvGetCell(const StringData* key) const {
int index = m_arr->getIndex(key);
return index != -1 ? getValueRef(index).getTypedAccessor() :
nvGetNotFound(key);
}
Variant NameValueTableWrapper::current() const {
return m_pos != ArrayData::invalid_index
? getValueRef(m_pos)
: Variant(false);
}
TypedValue* SharedMap::nvGet(int64_t k) const {
int index = getIndex(k);
if (index == -1) return nullptr;
return (TypedValue*)&getValueRef(index);
}
CVarRef NameValueTableWrapper::endRef() {
m_pos = iter_end();
return getValueRef(m_pos);
}
TypedValue* ArrayData::nvGetValueRef(ssize_t pos) {
return const_cast<TypedValue*>(getValueRef(pos).asTypedValue());
}
void ArrayData::fetchValue(ssize_t pos, Variant & v) const {
v = getValueRef(pos);
}
