bool CActiveDeterministicMasternodeManager::GetLocalAddress(CService& addrRet)
{
// First try to find whatever local address is specified by externalip option
bool fFoundLocal = GetLocal(addrRet) && CMasternode::IsValidNetAddr(addrRet);
if (!fFoundLocal && Params().NetworkIDString() == CBaseChainParams::REGTEST) {
if (Lookup("127.0.0.1", addrRet, GetListenPort(), false)) {
fFoundLocal = true;
}
}
if (!fFoundLocal) {
bool empty = true;
// If we have some peers, let's try to find our local address from one of them
g_connman->ForEachNodeContinueIf(CConnman::AllNodes, [&fFoundLocal, &empty](CNode* pnode) {
empty = false;
if (pnode->addr.IsIPv4())
fFoundLocal = GetLocal(activeMasternodeInfo.service, &pnode->addr) && CMasternode::IsValidNetAddr(activeMasternodeInfo.service);
return !fFoundLocal;
});
// nothing and no live connections, can't do anything for now
if (empty) {
strError = "Can't detect valid external address. Please consider using the externalip configuration option if problem persists. Make sure to use IPv4 address only.";
LogPrintf("CActiveDeterministicMasternodeManager::GetLocalAddress -- ERROR: %s\n", strError);
return false;
}
}
return true;
}
void SOCSquareRoot
( const DistMultiVec<Real>& x,
DistMultiVec<Real>& xRoot,
const DistMultiVec<Int>& orders,
const DistMultiVec<Int>& firstInds, Int cutoff )
{
DEBUG_ONLY(CSE cse("SOCSquareRoot"))
DistMultiVec<Real> d(x.Comm());
SOCDets( x, d, orders, firstInds );
ConeBroadcast( d, orders, firstInds );
auto roots = x;
ConeBroadcast( roots, orders, firstInds );
const Int localHeight = x.LocalHeight();
xRoot.SetComm( x.Comm() );
Zeros( xRoot, x.Height(), 1 );
for( Int iLoc=0; iLoc<localHeight; ++iLoc )
{
const Int i = x.GlobalRow(iLoc);
const Real x0 = roots.GetLocal(iLoc,0);
const Real det = d.GetLocal(iLoc,0);
const Real eta0 = Sqrt(x0+Sqrt(det))/Sqrt(Real(2));
if( i == firstInds.GetLocal(iLoc,0) )
xRoot.SetLocal( iLoc, 0, eta0 );
else
xRoot.SetLocal( iLoc, 0, x.GetLocal(iLoc,0)/(2*eta0) );
}
}
uint RarTime::GetDos()
{
RarLocalTime lt;
GetLocal(<);
uint DosTime=(lt.Second/2)|(lt.Minute<<5)|(lt.Hour<<11)|
(lt.Day<<16)|(lt.Month<<21)|((lt.Year-1980)<<25);
return DosTime;
}
wxString CRealControlSocket::GetLocalIP() const
{
wxIPV4address addr;
if (!GetLocal(addr))
return _T("");
return addr.IPAddress();
}
void SOCApply
( const AbstractDistMatrix<Real>& xPre,
const AbstractDistMatrix<Real>& yPre,
AbstractDistMatrix<Real>& zPre,
const AbstractDistMatrix<Int>& ordersPre,
const AbstractDistMatrix<Int>& firstIndsPre,
Int cutoff )
{
DEBUG_ONLY(CSE cse("SOCApply"))
AssertSameGrids( xPre, yPre, zPre, ordersPre, firstIndsPre );
ProxyCtrl ctrl;
ctrl.colConstrain = true;
ctrl.colAlign = 0;
auto xPtr = ReadProxy<Real,VC,STAR>(&xPre,ctrl);
auto yPtr = ReadProxy<Real,VC,STAR>(&yPre,ctrl);
auto zPtr = WriteProxy<Real,VC,STAR>(&zPre,ctrl);
auto ordersPtr = ReadProxy<Int,VC,STAR>(&ordersPre,ctrl);
auto firstIndsPtr = ReadProxy<Int,VC,STAR>(&firstIndsPre,ctrl);
auto& x = *xPtr;
auto& y = *yPtr;
auto& z = *zPtr;
auto& orders = *ordersPtr;
auto& firstInds = *firstIndsPtr;
SOCDots( x, y, z, orders, firstInds );
auto xRoots = x;
auto yRoots = y;
ConeBroadcast( xRoots, orders, firstInds );
ConeBroadcast( yRoots, orders, firstInds );
const Int localHeight = x.LocalHeight();
for( Int iLoc=0; iLoc<localHeight; ++iLoc )
{
const Int i = x.GlobalRow(iLoc);
const Int firstInd = firstInds.GetLocal(iLoc,0);
if( i != firstInd )
z.UpdateLocal
( iLoc, 0, xRoots.GetLocal(iLoc,0)*y.GetLocal(iLoc,0) +
yRoots.GetLocal(iLoc,0)*x.GetLocal(iLoc,0) );
}
}
void SOCApply
( const DistMultiVec<Real>& x,
const DistMultiVec<Real>& y,
DistMultiVec<Real>& z,
const DistMultiVec<Int>& orders,
const DistMultiVec<Int>& firstInds, Int cutoff )
{
DEBUG_ONLY(CSE cse("SOCApply"))
SOCDots( x, y, z, orders, firstInds );
auto xRoots = x;
auto yRoots = y;
ConeBroadcast( xRoots, orders, firstInds );
ConeBroadcast( yRoots, orders, firstInds );
const Int localHeight = x.LocalHeight();
for( Int iLoc=0; iLoc<localHeight; ++iLoc )
{
const Int i = x.GlobalRow(iLoc);
const Int firstInd = firstInds.GetLocal(iLoc,0);
if( i != firstInd )
z.UpdateLocal
( iLoc, 0, xRoots.GetLocal(iLoc,0)*y.GetLocal(iLoc,0) +
yRoots.GetLocal(iLoc,0)*x.GetLocal(iLoc,0) );
}
}
const IAccess* CFrame::GetAccess( std::string _name ) const
{
const IAccess* result = GetFormal( _name );
if( result != 0 ) {
return result;
}
result = GetLocal( _name );
if( result != 0 ) {
return result;
}
result = GetField( _name );
if( result != 0 ) {
return result;
}
return nullptr;
}
void SOCSquareRoot
( const ElementalMatrix<Real>& xPre,
ElementalMatrix<Real>& xRootPre,
const ElementalMatrix<Int>& ordersPre,
const ElementalMatrix<Int>& firstIndsPre,
Int cutoff )
{
DEBUG_ONLY(CSE cse("SOCSquareRoot"))
AssertSameGrids( xPre, xRootPre, ordersPre, firstIndsPre );
ProxyCtrl ctrl;
ctrl.colConstrain = true;
ctrl.colAlign = 0;
auto xPtr = ReadProxy<Real,VC,STAR>(&xPre,ctrl);
auto xRootPtr = WriteProxy<Real,VC,STAR>(&xRootPre,ctrl);
auto ordersPtr = ReadProxy<Int,VC,STAR>(&ordersPre,ctrl);
auto firstIndsPtr = ReadProxy<Int,VC,STAR>(&firstIndsPre,ctrl);
auto& x = *xPtr;
auto& xRoot = *xRootPtr;
auto& orders = *ordersPtr;
auto& firstInds = *firstIndsPtr;
DistMatrix<Real,VC,STAR> d(x.Grid());
SOCDets( x, d, orders, firstInds );
ConeBroadcast( d, orders, firstInds );
auto roots = x;
ConeBroadcast( roots, orders, firstInds );
const Int localHeight = x.LocalHeight();
xRoot.SetGrid( x.Grid() );
Zeros( xRoot, x.Height(), 1 );
for( Int iLoc=0; iLoc<localHeight; ++iLoc )
{
const Int i = x.GlobalRow(iLoc);
const Real x0 = roots.GetLocal(iLoc,0);
const Real det = d.GetLocal(iLoc,0);
const Real eta0 = Sqrt(x0+Sqrt(det))/Sqrt(Real(2));
if( i == firstInds.GetLocal(iLoc,0) )
xRoot.SetLocal( iLoc, 0, eta0 );
else
xRoot.SetLocal( iLoc, 0, x.GetLocal(iLoc,0)/(2*eta0) );
}
}
void RarTime::GetText(wchar *DateStr,size_t MaxSize,bool FullYear,bool FullMS)
{
if (IsSet())
{
RarLocalTime lt;
GetLocal(<);
if (FullMS)
swprintf(DateStr,MaxSize,L"%u-%02u-%02u %02u:%02u,%03u",lt.Year,lt.Month,lt.Day,lt.Hour,lt.Minute,lt.Reminder/10000);
else
if (FullYear)
swprintf(DateStr,MaxSize,L"%02u-%02u-%u %02u:%02u",lt.Day,lt.Month,lt.Year,lt.Hour,lt.Minute);
else
swprintf(DateStr,MaxSize,L"%02u-%02u-%02u %02u:%02u",lt.Day,lt.Month,lt.Year%100,lt.Hour,lt.Minute);
}
else
{
// We use escape before '?' to avoid weird C trigraph characters.
wcscpy(DateStr,FullYear ? L"\?\?-\?\?-\?\?\?\? \?\?:\?\?":L"\?\?-\?\?-\?\? \?\?:\?\?");
}
}
//---------------------------------------------------------------------------
int __fastcall TFileViewDlg::GetWriteFileName(AnsiString &as, int no)
{
if( (no >= 0) && (no < pCurPage->pList->Count) ){
as = pCurPage->pList->Get(no);
return TRUE;
}
else {
SYSTEMTIME tim;
GetLocal(&tim);
char bf[128];
sprintf(bf, "%02u%02u%02u%02u%02u%02u",
tim.wYear % 100,
tim.wMonth,
tim.wDay,
tim.wHour,
tim.wMinute,
tim.wSecond
);
as = bf;
return FALSE;
}
}
/*
Find variable with given name 'n'. If it is an upvalue, add this
upvalue into all intermediate functions.
*/
static int singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) {
if (fs == NULL) /* no more levels? */
return VVOID; /* default is global */
else {
int v = searchvar(fs, n); /* look up locals at current level */
if (v >= 0) { /* found? */
init_exp(var, VLOCAL, v); /* variable is local */
if (!base)
{
markupval(fs, v); /* local will be used as an upval */
}
#ifdef LUA_UTILITIES_NET
else
{
GetLocal(n, fs->ls);
}
#endif
return VLOCAL;
}
else { /* not found as local at current level; try upvalues */
int idx = searchupvalue(fs, n); /* try existing upvalues */
if (idx < 0) { /* not found? */
if (singlevaraux(fs->prev, n, var, 0) == VVOID) /* try upper levels */
return VVOID; /* not found; is a global */
/* else was LOCAL or UPVAL */
idx = newupvalue(fs, n, var); /* will be a new upvalue */
}
init_exp(var, VUPVAL, idx);
#ifdef LUA_UTILITIES_NET
GetUpvalue(n, fs->ls);
#endif
return VUPVAL;
}
}
}
static int singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) {
if (fs == NULL) { /* no more levels? */
init_exp(var, VGLOBAL, NO_REG); /* default is global variable */
return VGLOBAL;
}
else {
int v = searchvar(fs, n); /* look up at current level */
if (v >= 0) {
init_exp(var, VLOCAL, v);
if (!base)
{
markupval(fs, v); /* local will be used as an upval */
}
#ifdef LUA_UTILITIES_NET
else
{
GetLocal(n, fs->ls);
}
#endif
return VLOCAL;
}
else { /* not found at current level; try upper one */
if (singlevaraux(fs->prev, n, var, 0) == VGLOBAL)
return VGLOBAL;
var->u.s.info = indexupvalue(fs, n, var); /* else was LOCAL or UPVAL */
var->k = VUPVAL; /* upvalue in this level */
#ifdef LUA_UTILITIES_NET
GetUpvalue(n, fs->ls);
#endif
return VUPVAL;
}
}
}
void ThreadIRCSeed()
{
// Don't connect to IRC if we won't use IPv4 connections.
if (IsLimited(NET_IPV4))
return;
// ... or if we won't make outbound connections and won't accept inbound ones.
if (mapArgs.count("-connect") && fNoListen)
return;
// ... or if IRC is not enabled.
if (GetBoolArg("-irc", false))
return;
int nErrorWait = 10;
int nRetryWait = 10;
int nNameRetry = 0;
for(;;)
{
boost::this_thread::interruption_point();
CService addrConnect("92.243.23.21", 6667); // irc.lfnet.org
CService addrIRC("irc.lfnet.org", 6667, true);
if (addrIRC.IsValid())
addrConnect = addrIRC;
SOCKET hSocket;
if (!ConnectSocket(addrConnect, hSocket, nConnectTimeout))
{
LogPrintf("IRC connect failed\n");
nErrorWait = nErrorWait * 11 / 10;
if (Wait(nErrorWait += 60))
continue;
else
return;
};
if (!RecvUntil(hSocket, "Found your hostname", "using your IP address instead", "Couldn't look up your hostname", "ignoring hostname"))
{
closesocket(hSocket);
hSocket = INVALID_SOCKET;
nErrorWait = nErrorWait * 11 / 10;
if (Wait(nErrorWait += 60))
continue;
else
return;
};
CNetAddr addrIPv4("1.2.3.4"); // arbitrary IPv4 address to make GetLocal prefer IPv4 addresses
CService addrLocal;
std::string strMyName;
// Don't use our IP as our nick if we're not listening
// or if it keeps failing because the nick is already in use.
if (!fNoListen && GetLocal(addrLocal, &addrIPv4) && nNameRetry<3)
strMyName = EncodeAddress(GetLocalAddress(&addrConnect));
if (strMyName == "")
strMyName = strprintf("x%u", GetRand(1000000000));
Send(hSocket, strprintf("NICK %s\r", strMyName.c_str()).c_str());
Send(hSocket, strprintf("USER %s 8 * : %s\r", strMyName.c_str(), strMyName.c_str()).c_str());
int nRet = RecvUntil(hSocket, " 004 ", " 433 ");
if (nRet != 1)
{
closesocket(hSocket);
hSocket = INVALID_SOCKET;
if (nRet == 2)
{
LogPrintf("IRC name already in use\n");
nNameRetry++;
Wait(10);
continue;
};
nErrorWait = nErrorWait * 11 / 10;
if (Wait(nErrorWait += 60))
continue;
else
return;
};
nNameRetry = 0;
MilliSleep(500);
// Get our external IP from the IRC server and re-nick before joining the channel
CNetAddr addrFromIRC;
if (GetIPFromIRC(hSocket, strMyName, addrFromIRC))
{
LogPrintf("GetIPFromIRC() returned %s\n", addrFromIRC.ToString().c_str());
// Don't use our IP as our nick if we're not listening
if (!fNoListen && addrFromIRC.IsRoutable())
{
// IRC lets you to re-nick
AddLocal(addrFromIRC, LOCAL_IRC);
strMyName = EncodeAddress(GetLocalAddress(&addrConnect));
Send(hSocket, strprintf("NICK %s\r", strMyName.c_str()).c_str());
};
};
if (fTestNet)
{
Send(hSocket, "JOIN #sdcoinTEST\r");
Send(hSocket, "WHO #sdcoinTEST\r");
} else
{
// randomly join #StealthCash00-#StealthCash05
//int channel_number = GetRandInt(5);
// Channel number is always 0 for initial release
int channel_number = 0;
Send(hSocket, strprintf("JOIN #sdcoin%02d\r", channel_number).c_str());
Send(hSocket, strprintf("WHO #sdcoin%02d\r", channel_number).c_str());
};
int64_t nStart = GetTime();
std::string strLine;
strLine.reserve(10000);
while (RecvLineIRC(hSocket, strLine))
{
boost::this_thread::interruption_point();
if (strLine.empty() || strLine.size() > 900 || strLine[0] != ':')
continue;
std::vector<std::string> vWords;
ParseString(strLine, ' ', vWords);
if (vWords.size() < 2)
continue;
char pszName[10000];
pszName[0] = '\0';
if (vWords[1] == "352" && vWords.size() >= 8)
{
// index 7 is limited to 16 characters
// could get full length name at index 10, but would be different from join messages
strlcpy(pszName, vWords[7].c_str(), sizeof(pszName));
LogPrintf("IRC got who\n");
};
if (vWords[1] == "JOIN" && vWords[0].size() > 1)
{
// :[email protected] JOIN :#channelname
strlcpy(pszName, vWords[0].c_str() + 1, sizeof(pszName));
if (strchr(pszName, '!'))
*strchr(pszName, '!') = '\0';
LogPrintf("IRC got join\n");
};
if (pszName[0] == 'u')
{
CAddress addr;
if (DecodeAddress(pszName, addr))
{
addr.nTime = GetAdjustedTime();
if (addrman.Add(addr, addrConnect, 51 * 60))
LogPrintf("IRC got new address: %s\n", addr.ToString().c_str());
nGotIRCAddresses++;
} else
{
LogPrintf("IRC decode failed\n");
};
};
};
closesocket(hSocket);
hSocket = INVALID_SOCKET;
if (GetTime() - nStart > 20 * 60)
{
nErrorWait /= 3;
nRetryWait /= 3;
};
nRetryWait = nRetryWait * 11 / 10;
if (!Wait(nRetryWait += 60))
return;
};
}
//
// Bootup the Masternode, look for a 1000DRK input and register on the network
//
void CActiveMasternode::ManageStatus()
{
std::string errorMessage;
if(!fMasterNode) return;
if (fDebug) LogPrintf("CActiveMasternode::ManageStatus() - Begin\n");
//need correct blocks to send ping
if(Params().NetworkID() != CBaseChainParams::REGTEST && !masternodeSync.IsBlockchainSynced()) {
status = ACTIVE_MASTERNODE_SYNC_IN_PROCESS;
LogPrintf("CActiveMasternode::ManageStatus() - %s\n", GetStatus());
return;
}
if(status == ACTIVE_MASTERNODE_SYNC_IN_PROCESS) status = ACTIVE_MASTERNODE_INITIAL;
if(status == ACTIVE_MASTERNODE_INITIAL) {
CMasternode *pmn;
pmn = mnodeman.Find(pubKeyMasternode);
if(pmn != NULL) {
pmn->Check();
if(pmn->IsEnabled() && pmn->protocolVersion == PROTOCOL_VERSION) EnableHotColdMasterNode(pmn->vin, pmn->addr);
}
}
if(status != ACTIVE_MASTERNODE_STARTED) {
// Set defaults
status = ACTIVE_MASTERNODE_NOT_CAPABLE;
notCapableReason = "";
if(pwalletMain->IsLocked()){
notCapableReason = "Wallet is locked.";
LogPrintf("CActiveMasternode::ManageStatus() - not capable: %s\n", notCapableReason);
return;
}
if(pwalletMain->GetBalance() == 0){
notCapableReason = "Hot node, waiting for remote activation.";
LogPrintf("CActiveMasternode::ManageStatus() - not capable: %s\n", notCapableReason);
return;
}
if(strMasterNodeAddr.empty()) {
if(!GetLocal(service)) {
notCapableReason = "Can't detect external address. Please use the masternodeaddr configuration option.";
LogPrintf("CActiveMasternode::ManageStatus() - not capable: %s\n", notCapableReason);
return;
}
} else {
service = CService(strMasterNodeAddr);
}
if(Params().NetworkID() == CBaseChainParams::MAIN) {
if(service.GetPort() != 9999) {
notCapableReason = strprintf("Invalid port: %u - only 9999 is supported on mainnet.", service.GetPort());
LogPrintf("CActiveMasternode::ManageStatus() - not capable: %s\n", notCapableReason);
return;
}
} else if(service.GetPort() == 9999) {
notCapableReason = strprintf("Invalid port: %u - 9999 is only supported on mainnet.", service.GetPort());
LogPrintf("CActiveMasternode::ManageStatus() - not capable: %s\n", notCapableReason);
return;
}
LogPrintf("CActiveMasternode::ManageStatus() - Checking inbound connection to '%s'\n", service.ToString());
CNode *pnode = ConnectNode((CAddress)service, NULL, false);
if(!pnode){
notCapableReason = "Could not connect to " + service.ToString();
LogPrintf("CActiveMasternode::ManageStatus() - not capable: %s\n", notCapableReason);
return;
}
pnode->Release();
// Choose coins to use
CPubKey pubKeyCollateralAddress;
CKey keyCollateralAddress;
if(GetMasterNodeVin(vin, pubKeyCollateralAddress, keyCollateralAddress)) {
if(GetInputAge(vin) < MASTERNODE_MIN_CONFIRMATIONS){
status = ACTIVE_MASTERNODE_INPUT_TOO_NEW;
notCapableReason = strprintf("%s - %d confirmations", GetStatus(), GetInputAge(vin));
LogPrintf("CActiveMasternode::ManageStatus() - %s\n", notCapableReason);
return;
}
LOCK(pwalletMain->cs_wallet);
pwalletMain->LockCoin(vin.prevout);
// send to all nodes
CPubKey pubKeyMasternode;
CKey keyMasternode;
if(!darkSendSigner.SetKey(strMasterNodePrivKey, errorMessage, keyMasternode, pubKeyMasternode))
{
notCapableReason = "Error upon calling SetKey: " + errorMessage;
LogPrintf("Register::ManageStatus() - %s\n", notCapableReason);
return;
}
if(!Register(vin, service, keyCollateralAddress, pubKeyCollateralAddress, keyMasternode, pubKeyMasternode, errorMessage)) {
notCapableReason = "Error on Register: " + errorMessage;
LogPrintf("Register::ManageStatus() - %s\n", notCapableReason);
return;
}
LogPrintf("CActiveMasternode::ManageStatus() - Is capable master node!\n");
status = ACTIVE_MASTERNODE_STARTED;
return;
} else {
notCapableReason = "Could not find suitable coins!";
LogPrintf("CActiveMasternode::ManageStatus() - %s\n", notCapableReason);
return;
}
}
//send to all peers
if(!SendMasternodePing(errorMessage)) {
LogPrintf("CActiveMasternode::ManageStatus() - Error on Ping: %s\n", errorMessage);
}
}
//
// Bootup the Throne, look for a 1000DRK input and register on the network
//
void CActiveThrone::ManageStatus()
{
std::string errorMessage;
if(!fThroNe) return;
if (fDebug) LogPrintf("CActiveThrone::ManageStatus() - Begin\n");
//need correct adjusted time to send ping
bool fIsInitialDownload = IsInitialBlockDownload();
if(fIsInitialDownload) {
status = THRONE_SYNC_IN_PROCESS;
LogPrintf("CActiveThrone::ManageStatus() - Sync in progress. Must wait until sync is complete to start Throne.\n");
return;
}
if(status == THRONE_INPUT_TOO_NEW || status == THRONE_NOT_CAPABLE || status == THRONE_SYNC_IN_PROCESS){
status = THRONE_NOT_PROCESSED;
}
if(status == THRONE_NOT_PROCESSED) {
if(strThroNeAddr.empty()) {
if(!GetLocal(service)) {
notCapableReason = "Can't detect external address. Please use the Throneaddr configuration option.";
status = THRONE_NOT_CAPABLE;
LogPrintf("CActiveThrone::ManageStatus() - not capable: %s\n", notCapableReason.c_str());
return;
}
} else {
service = CService(strThroNeAddr);
}
LogPrintf("CActiveThrone::ManageStatus() - Checking inbound connection to '%s'\n", service.ToString().c_str());
if(Params().NetworkID() == CChainParams::MAIN){
if(service.GetPort() != 9340) {
notCapableReason = "Invalid port: " + boost::lexical_cast<string>(service.GetPort()) + " - only 9999 is supported on mainnet.";
status = THRONE_NOT_CAPABLE;
LogPrintf("CActiveThrone::ManageStatus() - not capable: %s\n", notCapableReason.c_str());
return;
}
} else if(service.GetPort() == 9340) {
notCapableReason = "Invalid port: " + boost::lexical_cast<string>(service.GetPort()) + " - 9999 is only supported on mainnet.";
status = THRONE_NOT_CAPABLE;
LogPrintf("CActiveThrone::ManageStatus() - not capable: %s\n", notCapableReason.c_str());
return;
}
if(!ConnectNode((CAddress)service, service.ToString().c_str())){
notCapableReason = "Could not connect to " + service.ToString();
status = THRONE_NOT_CAPABLE;
LogPrintf("CActiveThrone::ManageStatus() - not capable: %s\n", notCapableReason.c_str());
return;
}
if(pwalletMain->IsLocked()){
notCapableReason = "Wallet is locked.";
status = THRONE_NOT_CAPABLE;
LogPrintf("CActiveThrone::ManageStatus() - not capable: %s\n", notCapableReason.c_str());
return;
}
// Set defaults
status = THRONE_NOT_CAPABLE;
notCapableReason = "Unknown. Check debug.log for more information.\n";
// Choose coins to use
CPubKey pubKeyCollateralAddress;
CKey keyCollateralAddress;
if(GetThroNeVin(vin, pubKeyCollateralAddress, keyCollateralAddress)) {
if(GetInputAge(vin) < THRONE_MIN_CONFIRMATIONS){
notCapableReason = "Input must have least " + boost::lexical_cast<string>(THRONE_MIN_CONFIRMATIONS) +
" confirmations - " + boost::lexical_cast<string>(GetInputAge(vin)) + " confirmations";
LogPrintf("CActiveThrone::ManageStatus() - %s\n", notCapableReason.c_str());
status = THRONE_INPUT_TOO_NEW;
return;
}
LogPrintf("CActiveThrone::ManageStatus() - Is capable throne node!\n");
status = THRONE_IS_CAPABLE;
notCapableReason = "";
pwalletMain->LockCoin(vin.prevout);
// send to all nodes
CPubKey pubKeyThrone;
CKey keyThrone;
if(!darkSendSigner.SetKey(strThroNePrivKey, errorMessage, keyThrone, pubKeyThrone))
{
LogPrintf("Register::ManageStatus() - Error upon calling SetKey: %s\n", errorMessage.c_str());
return;
}
if(!Register(vin, service, keyCollateralAddress, pubKeyCollateralAddress, keyThrone, pubKeyThrone, errorMessage)) {
LogPrintf("CActiveThrone::ManageStatus() - Error on Register: %s\n", errorMessage.c_str());
}
return;
} else {
notCapableReason = "Could not find suitable coins!";
LogPrintf("CActiveThrone::ManageStatus() - %s\n", notCapableReason.c_str());
}
}
//send to all peers
if(!Dseep(errorMessage)) {
LogPrintf("CActiveThrone::ManageStatus() - Error on Ping: %s\n", errorMessage.c_str());
}
}
//
// Bootup the blanknode, look for a 1000 FNX input and register on the network
//
void CActiveBlanknode::ManageStatus()
{
std::string errorMessage;
if(!fBlankNode) return;
if (fDebug) LogPrintf("CActiveBlanknode::ManageStatus() - Begin\n");
//need correct adjusted time to send ping
bool fIsInitialDownload = IsInitialBlockDownload();
if(fIsInitialDownload) {
status = BLANKNODE_SYNC_IN_PROCESS;
LogPrintf("CActiveBlanknode::ManageStatus() - Sync in progress. Must wait until sync is complete to start blanknode.\n");
return;
}
if(status == BLANKNODE_INPUT_TOO_NEW || status == BLANKNODE_NOT_CAPABLE || status == BLANKNODE_SYNC_IN_PROCESS){
status = BLANKNODE_NOT_PROCESSED;
}
if(status == BLANKNODE_NOT_PROCESSED) {
if(strBlankNodeAddr.empty()) {
if(!GetLocal(service)) {
notCapableReason = "Can't detect external address. Please use the blanknodeaddr configuration option.";
status = BLANKNODE_NOT_CAPABLE;
LogPrintf("CActiveBlanknode::ManageStatus() - not capable: %s\n", notCapableReason.c_str());
return;
}
} else {
service = CService(strBlankNodeAddr);
}
LogPrintf("CActiveBlanknode::ManageStatus() - Checking inbound connection to '%s'\n", service.ToString().c_str());
// FNXNOTE: There is no logical reason to restrict this to a specific port. Its a peer, what difference does it make.
/* if(service.GetPort() != 31000) {
notCapableReason = "Invalid port: " + boost::lexical_cast<string>(service.GetPort()) + " -only 31000 is supported on mainnet.";
status = BLANKNODE_NOT_CAPABLE;
LogPrintf("CActiveBlanknode::ManageStatus() - not capable: %s\n", notCapableReason.c_str());
return;
}
} else if(service.GetPort() == 31000) {
notCapableReason = "Invalid port: " + boost::lexical_cast<string>(service.GetPort()) + " - 31000 is only supported on mainnet.";
status = BLANKNODE_NOT_CAPABLE;
LogPrintf("CActiveBlanknode::ManageStatus() - not capable: %s\n", notCapableReason.c_str());
return;
}
*/
if(!ConnectNode((CAddress)service, service.ToString().c_str())){
notCapableReason = "Could not connect to " + service.ToString();
status = BLANKNODE_NOT_CAPABLE;
LogPrintf("CActiveBlanknode::ManageStatus() - not capable: %s\n", notCapableReason.c_str());
return;
}
if(pwalletMain->IsLocked()){
notCapableReason = "Wallet is locked.";
status = BLANKNODE_NOT_CAPABLE;
LogPrintf("CActiveBlanknode::ManageStatus() - not capable: %s\n", notCapableReason.c_str());
return;
}
// Set defaults
status = BLANKNODE_NOT_CAPABLE;
notCapableReason = "Unknown. Check debug.log for more information.\n";
// Choose coins to use
CPubKey pubKeyCollateralAddress;
CKey keyCollateralAddress;
if(GetBlankNodeVin(vin, pubKeyCollateralAddress, keyCollateralAddress)) {
if(GetInputAge(vin) < BLANKNODE_MIN_CONFIRMATIONS){
notCapableReason = "Input must have least " + boost::lexical_cast<string>(BLANKNODE_MIN_CONFIRMATIONS) +
" confirmations - " + boost::lexical_cast<string>(GetInputAge(vin)) + " confirmations";
LogPrintf("CActiveBlanknode::ManageStatus() - %s\n", notCapableReason.c_str());
status = BLANKNODE_INPUT_TOO_NEW;
return;
}
LogPrintf("CActiveBlanknode::ManageStatus() - Is capable master node!\n");
status = BLANKNODE_IS_CAPABLE;
notCapableReason = "";
pwalletMain->LockCoin(vin.prevout);
// send to all nodes
CPubKey pubKeyBlanknode;
CKey keyBlanknode;
if(!zeroSendSigner.SetKey(strBlankNodePrivKey, errorMessage, keyBlanknode, pubKeyBlanknode))
{
LogPrintf("Register::ManageStatus() - Error upon calling SetKey: %s\n", errorMessage.c_str());
return;
}
/* donations are not supported in fantom.conf */
CScript donationAddress = CScript();
int donationPercentage = 0;
if(!Register(vin, service, keyCollateralAddress, pubKeyCollateralAddress, keyBlanknode, pubKeyBlanknode, donationAddress, donationPercentage, errorMessage)) {
LogPrintf("CActiveBlanknode::ManageStatus() - Error on Register: %s\n", errorMessage.c_str());
}
return;
} else {
LogPrintf("CActiveBlanknode::ManageStatus() - Could not find suitable coins!\n");
}
}
//send to all peers
if(!Sseep(errorMessage)) {
LogPrintf("CActiveBlanknode::ManageStatus() - Error on Ping: %s\n", errorMessage.c_str()); }
}
void CActiveLegacyMasternodeManager::ManageStateInitial(CConnman& connman)
{
if (deterministicMNManager->IsDeterministicMNsSporkActive()) return;
LogPrint("masternode", "CActiveLegacyMasternodeManager::ManageStateInitial -- status = %s, type = %s, pinger enabled = %d\n", GetStatus(), GetTypeString(), fPingerEnabled);
// Check that our local network configuration is correct
if (!fListen) {
// listen option is probably overwritten by smth else, no good
nState = ACTIVE_MASTERNODE_NOT_CAPABLE;
strNotCapableReason = "Masternode must accept connections from outside. Make sure listen configuration option is not overwritten by some another parameter.";
LogPrintf("CActiveLegacyMasternodeManager::ManageStateInitial -- %s: %s\n", GetStateString(), strNotCapableReason);
return;
}
// First try to find whatever local address is specified by externalip option
bool fFoundLocal = GetLocal(activeMasternodeInfo.service) && CMasternode::IsValidNetAddr(activeMasternodeInfo.service);
if (!fFoundLocal) {
bool empty = true;
// If we have some peers, let's try to find our local address from one of them
connman.ForEachNodeContinueIf(CConnman::AllNodes, [&fFoundLocal, &empty](CNode* pnode) {
empty = false;
if (pnode->addr.IsIPv4())
fFoundLocal = GetLocal(activeMasternodeInfo.service, &pnode->addr) && CMasternode::IsValidNetAddr(activeMasternodeInfo.service);
return !fFoundLocal;
});
// nothing and no live connections, can't do anything for now
if (empty) {
nState = ACTIVE_MASTERNODE_NOT_CAPABLE;
strNotCapableReason = "Can't detect valid external address. Will retry when there are some connections available.";
LogPrintf("CActiveLegacyMasternodeManager::ManageStateInitial -- %s: %s\n", GetStateString(), strNotCapableReason);
return;
}
}
if (!fFoundLocal && Params().NetworkIDString() == CBaseChainParams::REGTEST) {
if (Lookup("127.0.0.1", activeMasternodeInfo.service, GetListenPort(), false)) {
fFoundLocal = true;
}
}
if (!fFoundLocal) {
nState = ACTIVE_MASTERNODE_NOT_CAPABLE;
strNotCapableReason = "Can't detect valid external address. Please consider using the externalip configuration option if problem persists. Make sure to use IPv4 address only.";
LogPrintf("CActiveLegacyMasternodeManager::ManageStateInitial -- %s: %s\n", GetStateString(), strNotCapableReason);
return;
}
int mainnetDefaultPort = Params(CBaseChainParams::MAIN).GetDefaultPort();
if (Params().NetworkIDString() == CBaseChainParams::MAIN) {
if (activeMasternodeInfo.service.GetPort() != mainnetDefaultPort) {
nState = ACTIVE_MASTERNODE_NOT_CAPABLE;
strNotCapableReason = strprintf("Invalid port: %u - only %d is supported on mainnet.", activeMasternodeInfo.service.GetPort(), mainnetDefaultPort);
LogPrintf("CActiveLegacyMasternodeManager::ManageStateInitial -- %s: %s\n", GetStateString(), strNotCapableReason);
return;
}
} else if (activeMasternodeInfo.service.GetPort() == mainnetDefaultPort) {
nState = ACTIVE_MASTERNODE_NOT_CAPABLE;
strNotCapableReason = strprintf("Invalid port: %u - %d is only supported on mainnet.", activeMasternodeInfo.service.GetPort(), mainnetDefaultPort);
LogPrintf("CActiveLegacyMasternodeManager::ManageStateInitial -- %s: %s\n", GetStateString(), strNotCapableReason);
return;
}
if (Params().NetworkIDString() != CBaseChainParams::REGTEST) {
// Check socket connectivity
LogPrintf("CActiveLegacyMasternodeManager::ManageStateInitial -- Checking inbound connection to '%s'\n", activeMasternodeInfo.service.ToString());
SOCKET hSocket;
bool fConnected = ConnectSocket(activeMasternodeInfo.service, hSocket, nConnectTimeout) && IsSelectableSocket(hSocket);
CloseSocket(hSocket);
if (!fConnected) {
nState = ACTIVE_MASTERNODE_NOT_CAPABLE;
strNotCapableReason = "Could not connect to " + activeMasternodeInfo.service.ToString();
LogPrintf("CActiveLegacyMasternodeManager::ManageStateInitial -- %s: %s\n", GetStateString(), strNotCapableReason);
return;
}
}
// Default to REMOTE
eType = MASTERNODE_REMOTE;
LogPrint("masternode", "CActiveLegacyMasternodeManager::ManageStateInitial -- End status = %s, type = %s, pinger enabled = %d\n", GetStatus(), GetTypeString(), fPingerEnabled);
}
//
// Bootup the masternode, look for a 1000 NODX input and register on the network
//
void CActiveMasternode::ManageStatus()
{
std::string errorMessage;
if(!fMasterNode) return;
if (fDebug) LogPrintf("CActiveMasternode::ManageStatus() - Begin\n");
//need correct adjusted time to send ping
bool fIsInitialDownload = IsInitialBlockDownload();
if(fIsInitialDownload) {
status = MASTERNODE_SYNC_IN_PROCESS;
LogPrintf("CActiveMasternode::ManageStatus() - Sync in progress. Must wait until sync is complete to start masternode.\n");
return;
}
if(status == MASTERNODE_INPUT_TOO_NEW || status == MASTERNODE_NOT_CAPABLE || status == MASTERNODE_SYNC_IN_PROCESS){
status = MASTERNODE_NOT_PROCESSED;
}
if(status == MASTERNODE_NOT_PROCESSED) {
if(strMasterNodeAddr.empty()) {
if(!GetLocal(service)) {
notCapableReason = "Can't detect external address. Please use the masternodeaddr configuration option.";
status = MASTERNODE_NOT_CAPABLE;
LogPrintf("CActiveMasternode::ManageStatus() - not capable: %s\n", notCapableReason.c_str());
return;
}
} else {
service = CService(strMasterNodeAddr);
}
LogPrintf("CActiveMasternode::ManageStatus() - Checking inbound connection to '%s'\n", service.ToString().c_str());
if(!ConnectNode((CAddress)service, service.ToString().c_str())){
notCapableReason = "Could not connect to " + service.ToString();
status = MASTERNODE_NOT_CAPABLE;
LogPrintf("CActiveMasternode::ManageStatus() - not capable: %s\n", notCapableReason.c_str());
return;
}
if(pwalletMain->IsLocked()){
notCapableReason = "Wallet is locked.";
status = MASTERNODE_NOT_CAPABLE;
LogPrintf("CActiveMasternode::ManageStatus() - not capable: %s\n", notCapableReason.c_str());
return;
}
// Set defaults
status = MASTERNODE_NOT_CAPABLE;
notCapableReason = "Unknown. Check debug.log for more information.\n";
// Choose coins to use
CPubKey pubKeyCollateralAddress;
CKey keyCollateralAddress;
if(GetMasterNodeVin(vin, pubKeyCollateralAddress, keyCollateralAddress)) {
if(GetInputAge(vin) < MASTERNODE_MIN_CONFIRMATIONS){
LogPrintf("CActiveMasternode::ManageStatus() - Input must have least %d confirmations - %d confirmations\n", MASTERNODE_MIN_CONFIRMATIONS, GetInputAge(vin));
status = MASTERNODE_INPUT_TOO_NEW;
return;
}
LogPrintf("CActiveMasternode::ManageStatus() - Is capable master node!\n");
status = MASTERNODE_IS_CAPABLE;
notCapableReason = "";
pwalletMain->LockCoin(vin.prevout);
// send to all nodes
CPubKey pubKeyMasternode;
CKey keyMasternode;
if(!darkSendSigner.SetKey(strMasterNodePrivKey, errorMessage, keyMasternode, pubKeyMasternode))
{
LogPrintf("Register::ManageStatus() - Error upon calling SetKey: %s\n", errorMessage.c_str());
return;
}
if(!Register(vin, service, keyCollateralAddress, pubKeyCollateralAddress, keyMasternode, pubKeyMasternode, errorMessage)) {
LogPrintf("CActiveMasternode::ManageStatus() - Error on Register: %s\n", errorMessage.c_str());
}
return;
} else {
LogPrintf("CActiveMasternode::ManageStatus() - Could not find suitable coins!\n");
}
}
//send to all peers
if(!Dseep(errorMessage)) {
LogPrintf("CActiveMasternode::ManageStatus() - Error on Ping: %s", errorMessage.c_str());
}
}
void ExecuteCycle(VM* vm)
{
if(vm->pc == -1) return;
if(vm->debug)
printf("pc %i: ", vm->pc);
if(vm->stackSize < vm->numGlobals)
printf("Global(s) were removed from the stack!\n");
switch(vm->program[vm->pc])
{
case OP_PUSH_NULL:
{
if(vm->debug)
printf("push_null\n");
++vm->pc;
PushObject(vm, &NullObject);
} break;
case OP_PUSH_NUMBER:
{
if(vm->debug)
printf("push_number\n");
++vm->pc;
int index = ReadInteger(vm);
PushNumber(vm, vm->numberConstants[index]);
} break;
case OP_PUSH_STRING:
{
if(vm->debug)
printf("push_string\n");
++vm->pc;
int index = ReadInteger(vm);
PushString(vm, vm->stringConstants[index]);
} break;
case OP_PUSH_FUNC:
{
if(vm->debug)
printf("push_func\n");
Word hasEllipsis = vm->program[++vm->pc];
Word isExtern = vm->program[++vm->pc];
Word numArgs = vm->program[++vm->pc];
++vm->pc;
int index = ReadInteger(vm);
PushFunc(vm, index, hasEllipsis, isExtern, numArgs);
} break;
case OP_PUSH_DICT:
{
if(vm->debug)
printf("push_dict\n");
++vm->pc;
PushDict(vm);
} break;
case OP_CREATE_DICT_BLOCK:
{
if(vm->debug)
printf("create_dict_block\n");
++vm->pc;
int length = ReadInteger(vm);
Object* obj = PushDict(vm);
if(length > 0)
{
// stack (before dict) is filled with key-value pairs (backwards, key is higher on stack)
for(int i = 0; i < length * 2; i += 2)
DictPut(&obj->dict, vm->stack[vm->stackSize - i - 2]->string.raw, vm->stack[vm->stackSize - i - 3]);
vm->stackSize -= length * 2;
vm->stack[vm->stackSize - 1] = obj;
}
} break;
case OP_CREATE_ARRAY:
{
if(vm->debug)
printf("create_array\n");
++vm->pc;
int length = (int)PopNumber(vm);
PushArray(vm, length);
} break;
case OP_CREATE_ARRAY_BLOCK:
{
if(vm->debug)
printf("create_array_block\n");
++vm->pc;
int length = ReadInteger(vm);
Object* obj = PushArray(vm, length);
if(length > 0)
{
for(int i = 0; i < length; ++i)
obj->array.members[length - i - 1] = vm->stack[vm->stackSize - 2 - i];
vm->stackSize -= length;
vm->stack[vm->stackSize - 1] = obj;
}
} break;
case OP_LENGTH:
{
if(vm->debug)
printf("length\n");
++vm->pc;
Object* obj = PopObject(vm);
if(obj->type == OBJ_STRING)
PushNumber(vm, strlen(obj->string.raw));
else if(obj->type == OBJ_ARRAY)
PushNumber(vm, obj->array.length);
else
{
fprintf(stderr, "Attempted to get length of %s\n", ObjectTypeNames[obj->type]);
exit(1);
}
} break;
case OP_ARRAY_PUSH:
{
if(vm->debug)
printf("array_push\n");
++vm->pc;
Object* obj = PopArrayObject(vm);
Object* value = PopObject(vm);
while(obj->array.length + 1 >= obj->array.capacity)
{
obj->array.capacity *= 2;
obj->array.members = erealloc(obj->array.members, obj->array.capacity * sizeof(Object*));
}
obj->array.members[obj->array.length++] = value;
} break;
case OP_ARRAY_POP:
{
if(vm->debug)
printf("array_pop\n");
++vm->pc;
Object* obj = PopArrayObject(vm);
if(obj->array.length <= 0)
{
fprintf(stderr, "Cannot pop from empty array\n");
exit(1);
}
PushObject(vm, obj->array.members[--obj->array.length]);
} break;
case OP_ARRAY_CLEAR:
{
if(vm->debug)
printf("array_clear\n");
++vm->pc;
Object* obj = PopArrayObject(vm);
obj->array.length = 0;
} break;
case OP_DICT_SET:
{
if(vm->debug)
printf("dict_set\n");
++vm->pc;
Object* obj = PopDict(vm);
const char* key = PopString(vm);
Object* value = PopObject(vm);
DictPut(&obj->dict, key, value);
} break;
case OP_DICT_GET:
{
if(vm->debug)
printf("dict_get\n");
++vm->pc;
Object* obj = PopDict(vm);
const char* key = PopString(vm);
Object* value = DictGet(&obj->dict, key);
if(value)
PushObject(vm, value);
else
PushObject(vm, &NullObject);
} break;
case OP_DICT_PAIRS:
{
if(vm->debug)
printf("dict_pairs\n");
++vm->pc;
Object* obj = PopDict(vm);
Object* aobj = PushArray(vm, obj->dict.numEntries);
int len = 0;
for(int i = 0; i <= obj->dict.capacity; ++i)
{
DictNode* node = obj->dict.buckets[i];
while(node)
{
Object* pair = PushArray(vm, 2);
Object* key = NewObject(vm, OBJ_STRING);
key->string.raw = estrdup(node->key);
pair->array.members[0] = key;
pair->array.members[1] = node->value;
aobj->array.members[len++] = PopObject(vm);
node = node->next;
}
}
} break;
#define BIN_OP_TYPE(op, operator, type) case OP_##op: { if(vm->debug) printf("%s\n", #op); Object* val2 = PopObject(vm); Object* val1 = PopObject(vm); PushNumber(vm, (type)val1->number operator (type)val2->number); ++vm->pc; } break;
#define BIN_OP(op, operator) BIN_OP_TYPE(op, operator, double)
BIN_OP(ADD, +)
BIN_OP(SUB, -)
BIN_OP(MUL, *)
BIN_OP(DIV, /)
BIN_OP_TYPE(MOD, %, int)
BIN_OP_TYPE(OR, |, int)
BIN_OP_TYPE(AND, &, int)
BIN_OP(LT, <)
BIN_OP(LTE, <=)
BIN_OP(GT, >)
BIN_OP(GTE, >=)
BIN_OP_TYPE(LOGICAL_AND, &&, int)
BIN_OP_TYPE(LOGICAL_OR, ||, int)
#define CBIN_OP(op, operator) case OP_##op: { ++vm->pc; if(vm->debug) printf("%s\n", #op); Object* b = PopObject(vm); Object* a = PopObject(vm); a->number operator b->number; } break;
CBIN_OP(CADD, +=)
CBIN_OP(CSUB, -=)
CBIN_OP(CMUL, *=)
CBIN_OP(CDIV, /=)
case OP_EQU:
{
++vm->pc;
Object* o2 = PopObject(vm);
Object* o1 = PopObject(vm);
if(o1->type != o2->type) PushNumber(vm, 0);
else
{
if(o1->type == OBJ_STRING) { PushNumber(vm, strcmp(o1->string.raw, o2->string.raw) == 0); }
else if(o1->type == OBJ_NUMBER) { PushNumber(vm, o1->number == o2->number); }
else PushNumber(vm, o1 == o2);
}
} break;
case OP_NEQU:
{
++vm->pc;
Object* o2 = PopObject(vm);
Object* o1 = PopObject(vm);
if(o1->type != o2->type) PushNumber(vm, 1);
else
{
if(o1->type == OBJ_STRING) { PushNumber(vm, strcmp(o1->string.raw, o2->string.raw) != 0); }
else if(o1->type == OBJ_NUMBER) { PushNumber(vm, o1->number != o2->number); }
else PushNumber(vm, o1 != o2);
}
} break;
case OP_NEG:
{
if(vm->debug)
printf("neg\n");
++vm->pc;
Object* obj = PopObject(vm);
PushNumber(vm, -obj->number);
} break;
case OP_LOGICAL_NOT:
{
if(vm->debug)
printf("not\n");
++vm->pc;
Object* obj = PopObject(vm);
PushNumber(vm, !obj->number);
} break;
case OP_SETINDEX:
{
++vm->pc;
Object* obj = PopObject(vm);
Object* indexObj = PopObject(vm);
Object* value = PopObject(vm);
if(vm->debug)
printf("setindex\n");
if(obj->type == OBJ_ARRAY)
{
if(indexObj->type != OBJ_NUMBER)
{
fprintf(stderr, "Attempted to index array with a %s (expected number)\n", ObjectTypeNames[indexObj->type]);
exit(1);
}
int index = (int)indexObj->number;
int arrayLength = obj->array.length;
Object** members = obj->array.members;
if(index >= 0 && index < arrayLength)
members[index] = value;
else
{
fprintf(stderr, "Invalid array index %i\n", index);
exit(1);
}
}
else if(obj->type == OBJ_STRING)
{
if(indexObj->type != OBJ_NUMBER)
{
fprintf(stderr, "Attempted to index string with a %s (expected number)\n", ObjectTypeNames[indexObj->type]);
exit(1);
}
if(value->type != OBJ_NUMBER)
{
fprintf(stderr, "Attempted to assign a %s to an index of a string '%s' (expected number/character)\n", ObjectTypeNames[value->type], obj->string.raw);
exit(1);
}
obj->string.raw[(int)indexObj->number] = (char)value->number;
}
else if(obj->type == OBJ_DICT)
{
if(indexObj->type != OBJ_STRING)
{
fprintf(stderr, "Attempted to index dict with a %s (expected string)\n", ObjectTypeNames[indexObj->type]);
exit(1);
}
DictPut(&obj->dict, indexObj->string.raw, value);
}
else
{
fprintf(stderr, "Attempted to index a %s\n", ObjectTypeNames[obj->type]);
exit(1);
}
} break;
case OP_GETINDEX:
{
++vm->pc;
Object* obj = PopObject(vm);
Object* indexObj = PopObject(vm);
if(obj->type == OBJ_ARRAY)
{
if(indexObj->type != OBJ_NUMBER)
{
fprintf(stderr, "Attempted to index array with a %s (expected number)\n", ObjectTypeNames[indexObj->type]);
exit(1);
}
int index = (int)indexObj->number;
int arrayLength = obj->array.length;
Object** members = obj->array.members;
if(index >= 0 && index < arrayLength)
{
if(members[index])
PushObject(vm, members[index]);
else
{
fprintf(stderr, "attempted to index non-existent value in array\n");
exit(1);
}
if(vm->debug)
printf("getindex %i\n", index);
}
else
{
fprintf(stderr, "Invalid array index %i\n", index);
exit(1);
}
}
else if(obj->type == OBJ_STRING)
{
if(indexObj->type != OBJ_NUMBER)
{
fprintf(stderr, "Attempted to index string with a %s (expected number)\n", ObjectTypeNames[indexObj->type]);
exit(1);
}
PushNumber(vm, obj->string.raw[(int)indexObj->number]);
}
else if(obj->type == OBJ_DICT)
{
if(indexObj->type != OBJ_STRING)
{
fprintf(stderr, "Attempted to index dict with a %s (expected string)\n", ObjectTypeNames[indexObj->type]);
exit(1);
}
Object* val = (Object*)DictGet(&obj->dict, indexObj->string.raw);
if(val)
PushObject(vm, val);
else
PushObject(vm, &NullObject);
}
else
{
fprintf(stderr, "Attempted to index a %s\n", ObjectTypeNames[obj->type]);
exit(1);
}
} break;
case OP_SET:
{
++vm->pc;
int index = ReadInteger(vm);
Object* top = PopObject(vm);
vm->stack[index] = top;
if(vm->debug)
{
if(top->type == OBJ_NUMBER) printf("set %i to %g\n", index, top->number);
else if(top->type == OBJ_STRING) printf("set %i to %s\n", index, top->string);
}
} break;
case OP_GET:
{
++vm->pc;
int index = ReadInteger(vm);
if(vm->stack[index])
PushObject(vm, (vm->stack[index]));
else
PushObject(vm, &NullObject);
if(vm->debug)
printf("get %i\n", index);
} break;
case OP_WRITE:
{
if(vm->debug)
printf("write\n");
Object* top = PopObject(vm);
WriteObject(vm, top);
printf("\n");
++vm->pc;
} break;
case OP_READ:
{
if(vm->debug)
printf("read\n");
char* string = ReadStringFromStdin();
PushString(vm, string);
free(string);
++vm->pc;
} break;
case OP_GOTO:
{
++vm->pc;
int pc = ReadInteger(vm);
vm->pc = pc;
if(vm->debug)
printf("goto %i\n", vm->pc);
} break;
case OP_GOTOZ:
{
++vm->pc;
int pc = ReadInteger(vm);
Object* top = PopObject(vm);
if(top->number == 0)
{
vm->pc = pc;
if(vm->debug)
printf("gotoz %i\n", vm->pc);
}
} break;
case OP_CALL:
{
Word nargs = vm->program[++vm->pc];
++vm->pc;
int index = ReadInteger(vm);
if(vm->debug)
printf("call %s\n", vm->functionNames[index]);
PushIndir(vm, nargs);
vm->pc = vm->functionPcs[index];
} break;
case OP_CALLP:
{
Word hasEllipsis, isExtern, numArgs;
Word nargs = vm->program[++vm->pc];
++vm->pc;
int id = PopFunc(vm, &hasEllipsis, &isExtern, &numArgs);
if(vm->debug)
printf("callp %s%s\n", isExtern ? "extern " : "", isExtern ? vm->externNames[id] : vm->functionNames[id]);
if(isExtern)
vm->externs[id](vm);
else
{
if(!hasEllipsis)
{
if(nargs != numArgs)
{
fprintf(stderr, "Function '%s' expected %i args but recieved %i args\n", vm->functionNames[id], numArgs, nargs);
exit(1);
}
}
else
{
if(nargs < numArgs)
{
fprintf(stderr, "Function '%s' expected at least %i args but recieved %i args\n", vm->functionNames[id], numArgs, nargs);
exit(1);
}
}
if(!hasEllipsis) PushIndir(vm, nargs);
else
{
// runtime collapsing of arguments:
// the concrete arguments (known during compilation) are on the top of
// the stack. We create an array (by pushing it and then decrementing the
// stack pointer) and fill it up with the ellipsed arguments (behind the
// concrete arguments). We then place this array just before the concrete
// arguments in the stack so that it can be accessed as an argument "args".
// The indirection info is pushed onto the indirection stack (the concrete and
// non-concrete [aside from the one that the 'args' array replaces] are still
// present on the stack, so all of the arguments are to be removed)
/*printf("args:\n");
for(int i = 0; i < nargs; ++i)
{
WriteObject(vm, vm->stack[vm->stackSize - i - 1]);
printf("\n");
}
printf("end\n");*/
//printf("members:\n");
Object* obj = PushArray(vm, nargs - numArgs);
vm->stackSize -= 1;
for(int i = 0; i < obj->array.length; ++i)
{
obj->array.members[i] = vm->stack[vm->stackSize - numArgs - 1 - i];
/*WriteObject(vm, obj->array.members[i]);
printf("\n");*/
}
//printf("end\n");
vm->stack[vm->stackSize - numArgs - 1] = obj;
/*printf("final args:\n");
for(int i = 0; i < numArgs + 1; ++i)
{
WriteObject(vm, vm->stack[vm->stackSize - i - 1]);
printf("\n");
}
printf("end\n");*/
PushIndir(vm, nargs);
}
vm->pc = vm->functionPcs[id];
}
} break;
case OP_RETURN:
{
if(vm->debug)
printf("ret\n");
PopIndir(vm);
} break;
case OP_RETURN_VALUE:
{
if(vm->debug)
printf("retval\n");
Object* returnValue = PopObject(vm);
PopIndir(vm);
PushObject(vm, returnValue);
} break;
case OP_CALLF:
{
++vm->pc;
int index = ReadInteger(vm);
if(vm->debug)
printf("callf %s\n", vm->externNames[index]);
vm->externs[index](vm);
} break;
case OP_GETLOCAL:
{
++vm->pc;
int index = ReadInteger(vm);
PushObject(vm, GetLocal(vm, index));
if(vm->debug)
printf("getlocal %i (fp: %i, stack size: %i)\n", index, vm->fp, vm->stackSize);
} break;
case OP_SETLOCAL:
{
if(vm->debug)
printf("setlocal\n");
++vm->pc;
int index = ReadInteger(vm);
SetLocal(vm, index, PopObject(vm));
} break;
case OP_HALT:
{
if(vm->debug)
printf("halt\n");
vm->pc = -1;
} break;
default:
printf("Invalid instruction %i\n", vm->program[vm->pc]);
break;
}
}
void CActiveMasternode::ManageStateInitial(CConnman& connman)
{
LogPrint("masternode", "CActiveMasternode::ManageStateInitial -- status = %s, type = %s, pinger enabled = %d\n", GetStatus(), GetTypeString(), fPingerEnabled);
// Check that our local network configuration is correct
if (!fListen) {
// listen option is probably overwritten by smth else, no good
nState = ACTIVE_MASTERNODE_NOT_CAPABLE;
strNotCapableReason = "Masternode must accept connections from outside. Make sure listen configuration option is not overwritten by some another parameter.";
LogPrintf("CActiveMasternode::ManageStateInitial -- %s: %s\n", GetStateString(), strNotCapableReason);
return;
}
// First try to find whatever local address is specified by externalip option
bool fFoundLocal = GetLocal(service) && CMasternode::IsValidNetAddr(service);
if(!fFoundLocal) {
bool empty = true;
// If we have some peers, let's try to find our local address from one of them
connman.ForEachNodeContinueIf(CConnman::AllNodes, [&fFoundLocal, &empty, this](CNode* pnode) {
empty = false;
if (pnode->addr.IsIPv4())
fFoundLocal = GetLocal(service, &pnode->addr) && CMasternode::IsValidNetAddr(service);
return !fFoundLocal;
});
// nothing and no live connections, can't do anything for now
if (empty) {
nState = ACTIVE_MASTERNODE_NOT_CAPABLE;
strNotCapableReason = "Can't detect valid external address. Will retry when there are some connections available.";
LogPrintf("CActiveMasternode::ManageStateInitial -- %s: %s\n", GetStateString(), strNotCapableReason);
return;
}
}
if(!fFoundLocal) {
nState = ACTIVE_MASTERNODE_NOT_CAPABLE;
strNotCapableReason = "Can't detect valid external address. Please consider using the externalip configuration option if problem persists. Make sure to use IPv4 address only.";
LogPrintf("CActiveMasternode::ManageStateInitial -- %s: %s\n", GetStateString(), strNotCapableReason);
return;
}
int mainnetDefaultPort = Params(CBaseChainParams::MAIN).GetDefaultPort();
if(Params().NetworkIDString() == CBaseChainParams::MAIN) {
if(service.GetPort() != mainnetDefaultPort) {
nState = ACTIVE_MASTERNODE_NOT_CAPABLE;
strNotCapableReason = strprintf("Invalid port: %u - only %d is supported on mainnet.", service.GetPort(), mainnetDefaultPort);
LogPrintf("CActiveMasternode::ManageStateInitial -- %s: %s\n", GetStateString(), strNotCapableReason);
return;
}
} else if(service.GetPort() == mainnetDefaultPort) {
nState = ACTIVE_MASTERNODE_NOT_CAPABLE;
strNotCapableReason = strprintf("Invalid port: %u - %d is only supported on mainnet.", service.GetPort(), mainnetDefaultPort);
LogPrintf("CActiveMasternode::ManageStateInitial -- %s: %s\n", GetStateString(), strNotCapableReason);
return;
}
LogPrintf("CActiveMasternode::ManageStateInitial -- Checking inbound connection to '%s'\n", service.ToString());
if(!connman.ConnectNode(CAddress(service, NODE_NETWORK), NULL, true)) {
nState = ACTIVE_MASTERNODE_NOT_CAPABLE;
strNotCapableReason = "Could not connect to " + service.ToString();
LogPrintf("CActiveMasternode::ManageStateInitial -- %s: %s\n", GetStateString(), strNotCapableReason);
return;
}
// Default to REMOTE
eType = MASTERNODE_REMOTE;
// Check if wallet funds are available
if(!pwalletMain) {
LogPrintf("CActiveMasternode::ManageStateInitial -- %s: Wallet not available\n", GetStateString());
return;
}
if(pwalletMain->IsLocked()) {
LogPrintf("CActiveMasternode::ManageStateInitial -- %s: Wallet is locked\n", GetStateString());
return;
}
if(pwalletMain->GetBalance() < 1000*COIN) {
LogPrintf("CActiveMasternode::ManageStateInitial -- %s: Wallet balance is < 1000 TINCOIN\n", GetStateString());
return;
}
// Choose coins to use
CPubKey pubKeyCollateral;
CKey keyCollateral;
// If collateral is found switch to LOCAL mode
if(pwalletMain->GetMasternodeOutpointAndKeys(outpoint, pubKeyCollateral, keyCollateral)) {
eType = MASTERNODE_LOCAL;
}
LogPrint("masternode", "CActiveMasternode::ManageStateInitial -- End status = %s, type = %s, pinger enabled = %d\n", GetStatus(), GetTypeString(), fPingerEnabled);
}
void UUnb
( AbstractDistMatrix<F>& APre,
AbstractDistMatrix<F>& householderScalarsPre )
{
DEBUG_CSE
DistMatrixReadWriteProxy<F,F,MC,MR> AProx( APre );
DistMatrixWriteProxy<F,F,STAR,STAR>
householderScalarsProx( householderScalarsPre );
auto& A = AProx.Get();
auto& householderScalars = householderScalarsProx.Get();
const Grid& g = A.Grid();
const Int n = A.Height();
const Int householderScalarsHeight = Max(n-1,0);
householderScalars.SetGrid( g );
householderScalars.Resize( householderScalarsHeight, 1 );
DistMatrix<F,MC,STAR> a21_MC(g);
DistMatrix<F,MR,STAR> a21_MR(g);
DistMatrix<F,MC,STAR> x1_MC(g);
DistMatrix<F,MR,STAR> x12Adj_MR(g);
for( Int k=0; k<n-1; ++k )
{
const Range<Int> ind1( k, k+1 ),
ind2( k+1, n );
auto a21 = A( ind2, ind1 );
auto A22 = A( ind2, ind2 );
auto A2 = A( IR(0,n), ind2 );
auto alpha21T = A( IR(k+1,k+2), ind1 );
auto a21B = A( IR(k+2,n), ind1 );
// Find tau and v such that
// / I - tau | 1 | | 1, v^H | \ | alpha21T | = | beta |
// \ | v | / | a21B | | 0 |
const F tau = LeftReflector( alpha21T, a21B );
householderScalars.Set(k,0,tau);
// Temporarily set a21 := | 1 |
// | v |
F beta=0;
if( alpha21T.IsLocal(0,0) )
beta = alpha21T.GetLocal(0,0);
alpha21T.Set(0,0,F(1));
// A2 := A2 Hous(a21,tau)^H
// = A2 (I - conj(tau) a21 a21^H)
// = A2 - conj(tau) (A2 a21) a21^H
// -----------------------------------
// x1 := A2 a21
a21_MR.AlignWith( A2 );
a21_MR = a21;
x1_MC.AlignWith( A2 );
Zeros( x1_MC, n, 1 );
LocalGemv( NORMAL, F(1), A2, a21_MR, F(0), x1_MC );
El::AllReduce( x1_MC, A2.RowComm() );
// A2 := A2 - conj(tau) x1 a21^H
LocalGer( -Conj(tau), x1_MC, a21_MR, A2 );
// A22 := Hous(a21,tau) A22
// = (I - tau a21 a21^H) A22
// = A22 - tau a21 (A22^H a21)^H
// ----------------------------------
// x12^H := (a21^H A22)^H = A22^H a21
a21_MC.AlignWith( A22 );
a21_MC = a21;
x12Adj_MR.AlignWith( A22 );
Zeros( x12Adj_MR, A22.Width(), 1 );
LocalGemv( ADJOINT, F(1), A22, a21_MC, F(0), x12Adj_MR );
El::AllReduce( x12Adj_MR, A22.ColComm() );
// A22 := A22 - tau a21 x12
LocalGer( -tau, a21_MC, x12Adj_MR, A22 );
// Put beta back
if( alpha21T.IsLocal(0,0) )
alpha21T.SetLocal(0,0,beta);
}
}
