//-----------------------------------------------------------------------------
// Global functions define:
//-----------------------------------------------------------------------------
void ProtectAction()
{
handler_context_t *pProtectHandlerContext = (handler_context_t *)&g_HandlerContex;
if(IsExpired())
{
#ifndef _WIN32
//DeleteLicense();
#endif
SendReplyMsg_Prtt("Expired", prtt_expire, prtt_protect_rep);
}
else
{
if(app_os_is_file_exist(InstallPath))
{
if(!pProtectHandlerContext->isProtectActionRunning)
{
CAGENT_THREAD_HANDLE protectActionThreadHandle;
pProtectHandlerContext->isProtectActionRunning = TRUE;
if (app_os_thread_create(&protectActionThreadHandle, ProtectActionThreadStart, pProtectHandlerContext) != 0)
{
ProtectLog(g_loghandle, Warning, " %s> Start protect action thread failed!", strPluginName);
pProtectHandlerContext->isProtectActionRunning = FALSE;
}
}
else
{
SendReplyMsg_Prtt("ProtectActionRunning", prtt_busy, prtt_protect_rep);
}
}
}
}
void OnRemove(AuraEffect const* aurEff, AuraEffectHandleModes /*mode*/)
{
if (Unit* caster = GetCaster())
{
if (IsExpired())
caster->CastSpell((Unit*)NULL, SPELL_OCCUTHARS_DESTUCTION, true, NULL, aurEff);
caster->ToCreature()->DespawnOrUnsummon(500);
}
}
void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) // All-raid damage, 8-sec tick at time expire.
{
SpellInfo const* damageSpell = sSpellMgr->GetSpellInfo(SPELL_COUNTDOWN_DAMAGE);
int32 damage = damageSpell->Effects[EFFECT_0].CalcValue();
damage = int32(damage);
AuraRemoveMode removeMode = GetTargetApplication()->GetRemoveMode();
if (removeMode == AURA_REMOVE_BY_DEATH || !IsExpired())
return;
GetUnitOwner()->CastCustomSpell(SPELL_COUNTDOWN_DAMAGE, SPELLVALUE_BASE_POINT0, damage, GetUnitOwner(), true);
}
void OnRemove(AuraEffect const* aurEff, AuraEffectHandleModes /*mode*/)
{
if (!GetCaster())
return;
AuraRemoveMode removeMode = GetTargetApplication()->GetRemoveMode();
if (removeMode != AURA_REMOVE_BY_DEATH || !IsExpired())
return;
if (GetCaster()->ToPlayer()->isHonorOrXPTarget(GetTarget()))
GetCaster()->CastSpell(GetTarget(), SPELL_WARLOCK_CURSE_OF_DOOM_EFFECT, true, NULL, aurEff);
}
void
GeckoTouchDispatcher::DispatchTouchEvent(MultiTouchInput& aMultiTouch)
{
if ((aMultiTouch.mType == MultiTouchInput::MULTITOUCH_END ||
aMultiTouch.mType == MultiTouchInput::MULTITOUCH_CANCEL) &&
aMultiTouch.mTouches.Length() == 1) {
MutexAutoLock lock(mTouchQueueLock);
mTouchMoveEvents.clear();
} else if (aMultiTouch.mType == MultiTouchInput::MULTITOUCH_START &&
aMultiTouch.mTouches.Length() == 1) {
mTouchEventsFiltered = IsExpired(aMultiTouch);
}
if (mTouchEventsFiltered) {
return;
}
bool captured = false;
WidgetTouchEvent event = aMultiTouch.ToWidgetTouchEvent(nullptr);
nsEventStatus status = nsWindow::DispatchInputEvent(event, &captured);
if (mEnabledUniformityInfo) {
const char* touchAction = "Invalid";
switch (aMultiTouch.mType) {
case MultiTouchInput::MULTITOUCH_START:
touchAction = "Touch_Event_Down";
break;
case MultiTouchInput::MULTITOUCH_MOVE:
touchAction = "Touch_Event_Move";
break;
case MultiTouchInput::MULTITOUCH_END:
case MultiTouchInput::MULTITOUCH_CANCEL:
touchAction = "Touch_Event_Up";
break;
}
const SingleTouchData& firstTouch = aMultiTouch.mTouches[0];
const ScreenIntPoint& touchPoint = firstTouch.mScreenPoint;
LOG("UniformityInfo %s %llu %d %d", touchAction, systemTime(SYSTEM_TIME_MONOTONIC),
touchPoint.x, touchPoint.y);
}
if (!captured && (aMultiTouch.mTouches.Length() == 1)) {
bool forwardToChildren = status != nsEventStatus_eConsumeNoDefault;
DispatchMouseEvent(aMultiTouch, forwardToChildren);
}
}
void
GeckoTouchDispatcher::DispatchTouchEvent(MultiTouchInput aMultiTouch)
{
if ((aMultiTouch.mType == MultiTouchInput::MULTITOUCH_END ||
aMultiTouch.mType == MultiTouchInput::MULTITOUCH_CANCEL) &&
aMultiTouch.mTouches.Length() == 1) {
MutexAutoLock lock(mTouchQueueLock);
mTouchMoveEvents.clear();
} else if (aMultiTouch.mType == MultiTouchInput::MULTITOUCH_START &&
aMultiTouch.mTouches.Length() == 1) {
mTouchEventsFiltered = IsExpired(aMultiTouch);
}
if (mTouchEventsFiltered) {
return;
}
nsWindow::DispatchTouchInput(aMultiTouch);
if (mEnabledUniformityInfo && profiler_is_active()) {
const char* touchAction = "Invalid";
switch (aMultiTouch.mType) {
case MultiTouchInput::MULTITOUCH_START:
touchAction = "Touch_Event_Down";
break;
case MultiTouchInput::MULTITOUCH_MOVE:
touchAction = "Touch_Event_Move";
break;
case MultiTouchInput::MULTITOUCH_END:
case MultiTouchInput::MULTITOUCH_CANCEL:
touchAction = "Touch_Event_Up";
break;
case MultiTouchInput::MULTITOUCH_SENTINEL:
MOZ_ASSERT_UNREACHABLE("Invalid MultTouchInput.");
break;
}
const ScreenIntPoint& touchPoint = aMultiTouch.mTouches[0].mScreenPoint;
TouchDataPayload* payload = new TouchDataPayload(touchPoint);
PROFILER_MARKER_PAYLOAD(touchAction, payload);
}
}
void ExternalIPCounter::Rotate()
{
if (!IsExpired()) return;
if (_winnerV4 != _map.end()) {
byte ip_winner[4];
byte last_winner[4];
_winnerV4->first.compact(ip_winner, false);
_last_winner4.compact(last_winner, false);
// don't invoke the observer if last_votes is zero, that means this is the first
// IP we've seen
if(_last_votes4 && memcmp(ip_winner, last_winner, 4) && _ip_change_observer){
_ip_change_observer->on_ip_change(_winnerV4->first);
}
_last_winner4 = _winnerV4->first;
_last_votes4 = _winnerV4->second;
}
if (_winnerV6 != _map.end()) {
byte ip_winner[16];
byte last_winner[16];
_winnerV6->first.compact(ip_winner, false);
_last_winner6.compact(last_winner, false);
if(_last_votes6 && memcmp(ip_winner, last_winner, 16) && _ip_change_observer){
_ip_change_observer->on_ip_change(_winnerV6->first);
}
_last_winner6 = _winnerV6->first;
_last_votes6 = _winnerV6->second;
}
_map.clear();
_winnerV6 = _map.end();
_winnerV4 = _map.end();
_HeatStarted = time(NULL);
_TotalVotes = 0;
_voterFilter.clear();
}
void CMasternode::Check(bool fForce)
{
LOCK(cs);
if(ShutdownRequested()) return;
if(!fForce && (GetTime() - nTimeLastChecked < MASTERNODE_CHECK_SECONDS)) return;
nTimeLastChecked = GetTime();
LogPrint("masternode", "CMasternode::Check -- Masternode %s is in %s state\n", vin.prevout.ToStringShort(), GetStateString());
//once spent, stop doing the checks
if(IsOutpointSpent()) return;
int nHeight = 0;
if(!fUnitTest) {
TRY_LOCK(cs_main, lockMain);
if(!lockMain) return;
CCoins coins;
if(!pcoinsTip->GetCoins(vin.prevout.hash, coins) ||
(unsigned int)vin.prevout.n>=coins.vout.size() ||
coins.vout[vin.prevout.n].IsNull()) {
nActiveState = MASTERNODE_OUTPOINT_SPENT;
LogPrint("masternode", "CMasternode::Check -- Failed to find Masternode UTXO, masternode=%s\n", vin.prevout.ToStringShort());
return;
}
nHeight = chainActive.Height();
}
if(IsPoSeBanned()) {
if(nHeight < nPoSeBanHeight) return; // too early?
// Otherwise give it a chance to proceed further to do all the usual checks and to change its state.
// Masternode still will be on the edge and can be banned back easily if it keeps ignoring mnverify
// or connect attempts. Will require few mnverify messages to strengthen its position in mn list.
LogPrintf("CMasternode::Check -- Masternode %s is unbanned and back in list now\n", vin.prevout.ToStringShort());
DecreasePoSeBanScore();
} else if(nPoSeBanScore >= MASTERNODE_POSE_BAN_MAX_SCORE) {
nActiveState = MASTERNODE_POSE_BAN;
// ban for the whole payment cycle
nPoSeBanHeight = nHeight + mnodeman.size();
LogPrintf("CMasternode::Check -- Masternode %s is banned till block %d now\n", vin.prevout.ToStringShort(), nPoSeBanHeight);
return;
}
int nActiveStatePrev = nActiveState;
bool fOurMasternode = fMasterNode && activeMasternode.pubKeyMasternode == pubKeyMasternode;
// masternode doesn't meet payment protocol requirements ...
bool fRequireUpdate = nProtocolVersion < mnpayments.GetMinMasternodePaymentsProto() ||
// or it's our own node and we just updated it to the new protocol but we are still waiting for activation ...
(fOurMasternode && nProtocolVersion < PROTOCOL_VERSION);
if(fRequireUpdate) {
nActiveState = MASTERNODE_UPDATE_REQUIRED;
if(nActiveStatePrev != nActiveState) {
LogPrint("masternode", "CMasternode::Check -- Masternode %s is in %s state now\n", vin.prevout.ToStringShort(), GetStateString());
}
return;
}
// keep old masternodes on start, give them a chance to receive updates...
bool fWaitForPing = !masternodeSync.IsMasternodeListSynced() && !IsPingedWithin(MASTERNODE_MIN_MNP_SECONDS);
if(fWaitForPing && !fOurMasternode) {
// ...but if it was already expired before the initial check - return right away
if(IsExpired() || IsWatchdogExpired() || IsNewStartRequired()) {
LogPrint("masternode", "CMasternode::Check -- Masternode %s is in %s state, waiting for ping\n", vin.prevout.ToStringShort(), GetStateString());
return;
}
}
// don't expire if we are still in "waiting for ping" mode unless it's our own masternode
if(!fWaitForPing || fOurMasternode) {
if(!IsPingedWithin(MASTERNODE_NEW_START_REQUIRED_SECONDS)) {
nActiveState = MASTERNODE_NEW_START_REQUIRED;
if(nActiveStatePrev != nActiveState) {
LogPrint("masternode", "CMasternode::Check -- Masternode %s is in %s state now\n", vin.prevout.ToStringShort(), GetStateString());
}
return;
}
bool fWatchdogActive = masternodeSync.IsSynced() && mnodeman.IsWatchdogActive();
bool fWatchdogExpired = (fWatchdogActive && ((GetTime() - nTimeLastWatchdogVote) > MASTERNODE_WATCHDOG_MAX_SECONDS));
LogPrint("masternode", "CMasternode::Check -- outpoint=%s, nTimeLastWatchdogVote=%d, GetTime()=%d, fWatchdogExpired=%d\n",
vin.prevout.ToStringShort(), nTimeLastWatchdogVote, GetTime(), fWatchdogExpired);
if(fWatchdogExpired) {
nActiveState = MASTERNODE_WATCHDOG_EXPIRED;
if(nActiveStatePrev != nActiveState) {
LogPrint("masternode", "CMasternode::Check -- Masternode %s is in %s state now\n", vin.prevout.ToStringShort(), GetStateString());
}
return;
}
if(!IsPingedWithin(MASTERNODE_EXPIRATION_SECONDS)) {
nActiveState = MASTERNODE_EXPIRED;
if(nActiveStatePrev != nActiveState) {
LogPrint("masternode", "CMasternode::Check -- Masternode %s is in %s state now\n", vin.prevout.ToStringShort(), GetStateString());
}
return;
}
}
if(lastPing.sigTime - sigTime < MASTERNODE_MIN_MNP_SECONDS) {
nActiveState = MASTERNODE_PRE_ENABLED;
if(nActiveStatePrev != nActiveState) {
LogPrint("masternode", "CMasternode::Check -- Masternode %s is in %s state now\n", vin.prevout.ToStringShort(), GetStateString());
}
return;
}
nActiveState = MASTERNODE_ENABLED; // OK
if(nActiveStatePrev != nActiveState) {
LogPrint("masternode", "CMasternode::Check -- Masternode %s is in %s state now\n", vin.prevout.ToStringShort(), GetStateString());
}
}
ConstructorProxy<T> GetObject(DBID db, const Data& key, uint32_t expected_type, bool create_if_notexist,
int& err, bool* created = NULL)
{
if (NULL != created)
{
*created = false;
}
err = 0;
ConstructorProxy<T> proxy;
MMKVTable* kv = GetMMKVTable(db, create_if_notexist);
if (NULL == kv)
{
err = ERR_DB_NOT_EXIST;
return proxy;
}
Object tmpkey(key, false);
if (create_if_notexist)
{
std::pair<MMKVTable::iterator, bool> ret = kv->insert(MMKVTable::value_type(tmpkey, Object()));
//Object& value_data = const_cast<Object&>(ret.first.value());
Object& value_data = ret.first->second;
if (ret.second)
{
m_segment.AssignObjectValue(const_cast<Object&>(ret.first->first), key, false);
// if (ret.second)
// {
// m_segment.AssignObjectValue(const_cast<Object&>(ret.first->first), key, false);
// }
// else
// {
// GenericDelValue(value_data);
// }
m_segment.ObjectMakeRoom(value_data, sizeof(T));
value_data.type = expected_type;
proxy.invoke_constructor = true;
proxy.ptr = (T*) value_data.RawValue();
if (NULL != created)
{
*created = true;
}
}
else
{
if (value_data.type != expected_type)
{
err = ERR_INVALID_TYPE;
return proxy;
}
proxy.ptr = (T*) (ret.first->second.RawValue());
proxy.invoke_constructor = false;
}
}
else
{
MMKVTable::iterator found = kv->find(tmpkey);
if (found != kv->end())
{
Object& value_data = found->second;
if (IsExpired(db, key, value_data))
{
err = ERR_ENTRY_NOT_EXIST;
return proxy;
}
if (value_data.type == expected_type)
{
proxy.invoke_constructor = false;
proxy.ptr = (T*) (value_data.RawValue());
}
else
{
err = ERR_INVALID_TYPE;
}
}
else
{
err = ERR_ENTRY_NOT_EXIST;
}
}
return proxy;
}
// ---------------------------------------
bool MTRecord::FormatDescription(std::string & str_output)
{
OTString strDescription, strStatus, strKind;
if (IsRecord())
{
if (IsExpired())
strStatus = "(EXPIRED)"; // How to tell difference between instrument that processed successfully and THEN expired, versus one that expired before processing successfully? (See next comment.)
else if (IsInvoice())
strStatus = "(payment sent)"; // TODO: need an "invalid records" box for expired and canceled. Otherwise we may falsely assume "payment sent" when actually it expired. (We may also falsely assume payment expired when actually it was sent.) Solution is a new box.
else
strStatus = "";
// strStatus = "(record)";
}
// -----------------------------
else if (IsPending())
{
if (IsExpired())
strStatus = "(EXPIRED)";
else if (IsInvoice())
strStatus = "(unpaid)";
else if (!IsCash())
strStatus = "(pending)";
}
// -----------------------------
if (IsCanceled())
{
strStatus = "(CANCELED)";
if (IsOutgoing() || IsReceipt())
strKind.Format("%s", "sent ");
}
// -----------------------------
else
{
if (IsOutgoing())
strKind.Format("%s",
((IsPending() && !IsCash()) ? "outgoing " : "sent "));
else // incoming.
strKind.Format("%s",
IsPending() ? "incoming " : (IsReceipt() ? "" : "received "));
}
// -----------------------------
OTString strTransNumForDisplay;
if (!IsCash())
strTransNumForDisplay.Format(" #%ld", GetTransNumForDisplay());
// -----------------------------
if (IsRecord())
{
if (this->IsTransfer())
strDescription.Format("%s%s%s %s", strKind.Get(), "transfer", strTransNumForDisplay.Get(), strStatus.Get());
else if (this->IsVoucher())
strDescription.Format("%s%s%s %s", strKind.Get(), "payment", strTransNumForDisplay.Get(), strStatus.Get());
else if (this->IsReceipt())
{
std::string str_instrument_type;
if (0 == GetInstrumentType().compare("transferReceipt"))
str_instrument_type = "transfer";
else if (0 == GetInstrumentType().compare("finalReceipt"))
str_instrument_type = "final receipt (closed)";
else if (0 == GetInstrumentType().compare("chequeReceipt"))
{
const long lAmount = OTAPI_Wrap::It()->StringToLong(m_str_amount);
// I paid OUT when this chequeReceipt came through. It must be a normal cheque that I wrote.
if (lAmount <= 0) // Notice less than OR EQUAL TO 0 -- that's because a canceled cheque has a 0 value.
str_instrument_type = "cheque";
else // I GOT PAID when this chequeReceipt came through. It must be an invoice I wrote, that someone paid.
{
if (IsCanceled())
str_instrument_type = "invoice";
else
str_instrument_type = "invoice (payment received)";
}
}
else if (0 == GetInstrumentType().compare("voucherReceipt"))
{
str_instrument_type = "payment";
}
else if (0 == GetInstrumentType().compare("paymentReceipt"))
{
const long lAmount = OTAPI_Wrap::It()->StringToLong(m_str_amount);
if (!IsCanceled() && (lAmount > 0))
strKind.Set("received ");
str_instrument_type = "recurring payment";
}
strDescription.Format("%s%s%s %s", strKind.Get(), str_instrument_type.c_str(), strTransNumForDisplay.Get(), strStatus.Get());
}
else
strDescription.Format("%s%s%s %s", strKind.Get(), GetInstrumentType().c_str(), strTransNumForDisplay.Get(), strStatus.Get());
}
else
{
if (this->IsTransfer())
strDescription.Format("%s %s%s%s", strStatus.Get(), strKind.Get(), "transfer", strTransNumForDisplay.Get());
else if (this->IsVoucher())
strDescription.Format("%s %s%s%s", strStatus.Get(), strKind.Get(), "payment", strTransNumForDisplay.Get());
else if (this->IsReceipt())
{
std::string str_instrument_type;
if (0 == GetInstrumentType().compare("transferReceipt"))
{
if (IsCanceled())
str_instrument_type = "transfer";
else
str_instrument_type = "transfer (receipt)";
}
else if (0 == GetInstrumentType().compare("finalReceipt"))
str_instrument_type = "final receipt";
else if (0 == GetInstrumentType().compare("chequeReceipt"))
{
const long lAmount = OTAPI_Wrap::It()->StringToLong(m_str_amount);
// I paid OUT when this chequeReceipt came through. It must be a normal cheque that I wrote.
if (lAmount <= 0) // Notice less than OR EQUAL TO 0 -- that's because a canceled cheque has a 0 value.
{
if (IsCanceled())
str_instrument_type = "cheque";
else
str_instrument_type = "cheque (receipt)";
}
else // I GOT PAID when this chequeReceipt came through. It must be an invoice I wrote, that someone paid.
{
if (IsCanceled())
str_instrument_type = "invoice";
else
str_instrument_type = "sent invoice (receipt: payment received)";
}
}
else if (0 == GetInstrumentType().compare("voucherReceipt"))
{
if (IsCanceled())
str_instrument_type = "payment";
else
str_instrument_type = "payment (receipt)";
}
else if (0 == GetInstrumentType().compare("paymentReceipt"))
{
const long lAmount = OTAPI_Wrap::It()->StringToLong(m_str_amount);
if (!IsCanceled() && (lAmount > 0))
strKind.Set("received ");
str_instrument_type = "recurring payment (receipt)";
}
strDescription.Format("%s %s%s%s", strStatus.Get(), strKind.Get(), str_instrument_type.c_str(), strTransNumForDisplay.Get());
}
else
strDescription.Format("%s %s%s%s", strStatus.Get(), strKind.Get(), GetInstrumentType().c_str(), strTransNumForDisplay.Get());
}
// -----------------------------
str_output = strDescription.Get();
// -----------------------------
return (!str_output.empty());
}
void Dynacoe::Clock::OnDraw() {
if (!GetHost() || IsExpired()) return;
float ratio = lastDuration < 0 ? 1.f : GetTimeLeft() / float (lastDuration);
std::string data = (Chain() << ratio);
EmitEvent("clock-draw");
}
void Dynacoe::Clock::OnStep() {
if (!GetHost() || IsExpired()) return;
EmitEvent("clock-step");
}
void CSourceSaver::LoadSourcesFromFile(CPartFile* , SourceList* sources, LPCTSTR slsfile)
{
CString strLine;
CStdioFile f;
if (!f.Open(slsfile, CFile::modeRead | CFile::typeText))
return;
while(f.ReadString(strLine)) {
if (strLine.GetAt(0) == '#')
continue;
int pos = strLine.Find(':');
if (pos == -1)
continue;
CString strIP = strLine.Left(pos);
strLine = strLine.Mid(pos+1);
uint32 dwID = inet_addr(CT2CA(strIP));
if (dwID == INADDR_NONE)
continue;
pos = strLine.Find(',');
if (pos == -1)
continue;
CString strPort = strLine.Left(pos);
strLine = strLine.Mid(pos+1);
uint16 wPort = (uint16)_tstoi(strPort);
if (!wPort)
continue;
// khaos::kmod+ Src Ex Ver
pos = strLine.Find(',');
if (pos == -1)
continue;
CString strExpiration = strLine.Left(pos);
if (IsExpired(strExpiration))
continue;
strLine = strLine.Mid(pos+1);
pos = strLine.Find(',');
if (pos == -1)
continue;
uint8 nSrcExchangeVer = (uint8)_tstoi(strLine.Left(pos));
strLine = strLine.Mid(pos+1);
pos = strLine.Find(':');
if (pos == -1)
continue;
CString strserverip = strLine.Left(pos);
strLine = strLine.Mid(pos+1);
uint32 dwserverip = inet_addr(CT2CA(strserverip));
if (dwserverip == INADDR_NONE)
continue;
pos = strLine.Find(';');
if (pos == -1 || strLine.GetLength() < 2)
continue;
CString strserverport = strLine.Left(pos);
uint16 wserverport = (uint16)_tstoi(strserverport);
if (!wserverport)
continue;
CSourceData* newsource = new CSourceData(dwID, wPort, dwserverip, wserverport, strExpiration, nSrcExchangeVer);
// khaos::kmod-
sources->AddTail(newsource);
}
f.Close();
}
void CMasternode::Check(bool fForce)
{
AssertLockHeld(cs_main);
LOCK(cs);
if (ShutdownRequested()) return;
if (!fForce && (GetTime() - nTimeLastChecked < MASTERNODE_CHECK_SECONDS)) return;
nTimeLastChecked = GetTime();
LogPrint(MCLog::MN, "CMasternode::Check -- Masternode %s is in %s state\n", outpoint.ToStringShort(), GetStateString());
//once spent, stop doing the checks
if (IsOutpointSpent()) return;
int nHeight = 0;
if (!fUnitTest) {
Coin coin;
if (!GetUTXOCoin(outpoint, coin)) {
nActiveState = MASTERNODE_OUTPOINT_SPENT;
LogPrint(MCLog::MN, "CMasternode::Check -- Failed to find Masternode UTXO, masternode=%s\n", outpoint.ToStringShort());
return;
}
nHeight = chainActive.Height();
}
if (IsPoSeBanned()) {
if (nHeight < nPoSeBanHeight) return; // too early?
// Otherwise give it a chance to proceed further to do all the usual checks and to change its state.
// Masternode still will be on the edge and can be banned back easily if it keeps ignoring mnverify
// or connect attempts. Will require few mnverify messages to strengthen its position in mn list.
LogPrint(MCLog::MN, "CMasternode::Check -- Masternode %s is unbanned and back in list now\n", outpoint.ToStringShort());
DecreasePoSeBanScore();
} else if (nPoSeBanScore >= MASTERNODE_POSE_BAN_MAX_SCORE) {
nActiveState = MASTERNODE_POSE_BAN;
// ban for the whole payment cycle
nPoSeBanHeight = nHeight + mnodeman.size();
LogPrint(MCLog::MN, "CMasternode::Check -- Masternode %s is banned till block %d now\n", outpoint.ToStringShort(), nPoSeBanHeight);
return;
}
int nActiveStatePrev = nActiveState;
bool fOurMasternode = fMasternodeMode && activeMasternode.pubKeyMasternode == pubKeyMasternode;
// masternode doesn't meet payment protocol requirements ...
bool fRequireUpdate = nProtocolVersion < mnpayments.GetMinMasternodePaymentsProto() ||
// or it's our own node and we just updated it to the new protocol but we are still waiting for activation ...
(fOurMasternode && nProtocolVersion < PROTOCOL_VERSION);
if (fRequireUpdate) {
nActiveState = MASTERNODE_UPDATE_REQUIRED;
if (nActiveStatePrev != nActiveState) {
LogPrint(MCLog::MN, "CMasternode::Check -- Masternode %s is in %s state now\n", outpoint.ToStringShort(), GetStateString());
}
return;
}
// keep old masternodes on start, give them a chance to receive updates...
bool fWaitForPing = !masternodeSync.IsMasternodeListSynced() && !IsPingedWithin(MASTERNODE_MIN_MNP_SECONDS);
if (fWaitForPing && !fOurMasternode) {
// ...but if it was already expired before the initial check - return right away
if (IsExpired() || IsSentinelPingExpired() || IsNewStartRequired()) {
LogPrint(MCLog::MN, "CMasternode::Check -- Masternode %s is in %s state, waiting for ping\n", outpoint.ToStringShort(), GetStateString());
return;
}
}
// don't expire if we are still in "waiting for ping" mode unless it's our own masternode
if (!fWaitForPing || fOurMasternode) {
if (!IsPingedWithin(MASTERNODE_NEW_START_REQUIRED_SECONDS)) {
nActiveState = MASTERNODE_NEW_START_REQUIRED;
if (nActiveStatePrev != nActiveState) {
LogPrint(MCLog::MN, "CMasternode::Check -- Masternode %s is in %s state now\n", outpoint.ToStringShort(), GetStateString());
}
return;
}
if (!IsPingedWithin(MASTERNODE_EXPIRATION_SECONDS)) {
nActiveState = MASTERNODE_EXPIRED;
if (nActiveStatePrev != nActiveState) {
LogPrint(MCLog::MN, "CMasternode::Check -- Masternode %s is in %s state now\n", outpoint.ToStringShort(), GetStateString());
}
return;
}
// part 1: expire based on machinecoind ping
bool fSentinelPingActive = masternodeSync.IsSynced() && mnodeman.IsSentinelPingActive();
bool fSentinelPingExpired = fSentinelPingActive && !IsPingedWithin(MASTERNODE_SENTINEL_PING_MAX_SECONDS);
LogPrint(MCLog::MN, "CMasternode::Check -- outpoint=%s, GetAdjustedTime()=%d, fSentinelPingExpired=%d\n",
outpoint.ToStringShort(), GetAdjustedTime(), fSentinelPingExpired);
if (fSentinelPingExpired) {
nActiveState = MASTERNODE_SENTINEL_PING_EXPIRED;
if (nActiveStatePrev != nActiveState) {
LogPrint(MCLog::MN, "CMasternode::Check -- Masternode %s is in %s state now\n", outpoint.ToStringShort(), GetStateString());
}
return;
}
}
// We require MNs to be in PRE_ENABLED until they either start to expire or receive a ping and go into ENABLED state
// Works on mainnet/testnet only and not the case on regtest.
if (Params().NetworkIDString() != CBaseChainParams::REGTEST) {
if (lastPing.sigTime - sigTime < MASTERNODE_MIN_MNP_SECONDS) {
nActiveState = MASTERNODE_PRE_ENABLED;
if (nActiveStatePrev != nActiveState) {
LogPrint(MCLog::MN, "CMasternode::Check -- Masternode %s is in %s state now\n", outpoint.ToStringShort(), GetStateString());
}
return;
}
}
if (!fWaitForPing || fOurMasternode) {
// part 2: expire based on sentinel info
bool fSentinelPingActive = masternodeSync.IsSynced() && mnodeman.IsSentinelPingActive();
bool fSentinelPingExpired = fSentinelPingActive && !lastPing.fSentinelIsCurrent;
LogPrint(MCLog::MN, "CMasternode::Check -- outpoint=%s, GetAdjustedTime()=%d, fSentinelPingExpired=%d\n",
outpoint.ToStringShort(), GetAdjustedTime(), fSentinelPingExpired);
if (fSentinelPingExpired) {
nActiveState = MASTERNODE_SENTINEL_PING_EXPIRED;
if (nActiveStatePrev != nActiveState) {
LogPrint(MCLog::MN, "CMasternode::Check -- Masternode %s is in %s state now\n", outpoint.ToStringShort(), GetStateString());
}
return;
}
}
nActiveState = MASTERNODE_ENABLED; // OK
if (nActiveStatePrev != nActiveState) {
LogPrint(MCLog::MN, "CMasternode::Check -- Masternode %s is in %s state now\n", outpoint.ToStringShort(), GetStateString());
}
}
