/* Update our model of the wallet incrementally, to synchronize our model of the wallet
with that of the core.
Call with transaction that was added, removed or changed.
*/
void updateWallet(const uint256 &hash, int status)
{
//LogPrintf("updateWallet %s %i\n", hash.ToString().c_str(), status);
{
LOCK2(cs_main, wallet->cs_wallet);
// Find transaction in wallet
std::map<uint256, CWalletTx>::iterator mi = wallet->mapWallet.find(hash);
bool inWallet = mi != wallet->mapWallet.end();
// Find bounds of this transaction in model
QList<TransactionRecord>::iterator lower = qLowerBound(
cachedWallet.begin(), cachedWallet.end(), hash, TxLessThan());
QList<TransactionRecord>::iterator upper = qUpperBound(
cachedWallet.begin(), cachedWallet.end(), hash, TxLessThan());
int lowerIndex = (lower - cachedWallet.begin());
int upperIndex = (upper - cachedWallet.begin());
bool inModel = (lower != upper);
// Determine whether to show transaction or not
bool showTransaction = (inWallet && TransactionRecord::showTransaction(mi->second));
if (status == CT_UPDATED)
{
if (showTransaction && !inModel)
status = CT_NEW; /* Not in model, but want to show, treat as new */
if (!showTransaction && inModel)
status = CT_DELETED; /* In model, but want to hide, treat as deleted */
};
LogPrintf(" inWallet=%i inModel=%i Index=%i-%i showTransaction=%i derivedStatus=%i\n",
inWallet, inModel, lowerIndex, upperIndex, showTransaction, status);
switch(status)
{
case CT_NEW:
if(inModel)
{
LogPrintf("Warning: updateWallet: Got CT_NEW, but transaction is already in model\n");
break;
}
if(!inWallet)
{
LogPrintf("Warning: updateWallet: Got CT_NEW, but transaction is not in wallet\n");
break;
}
if(showTransaction)
{
// Added -- insert at the right position
QList<TransactionRecord> toInsert =
TransactionRecord::decomposeTransaction(wallet, mi->second);
if(!toInsert.isEmpty()) /* only if something to insert */
{
parent->beginInsertRows(QModelIndex(), lowerIndex, lowerIndex+toInsert.size()-1);
int insert_idx = lowerIndex;
foreach(const TransactionRecord &rec, toInsert)
{
cachedWallet.insert(insert_idx, rec);
insert_idx += 1;
}
parent->endInsertRows();
}
}
break;
case CT_DELETED:
if(!inModel)
{
LogPrintf("Warning: updateWallet: Got CT_DELETED, but transaction is not in model\n");
break;
}
// Removed -- remove entire transaction from table
parent->beginRemoveRows(QModelIndex(), lowerIndex, upperIndex-1);
cachedWallet.erase(lower, upper);
parent->endRemoveRows();
break;
case CT_UPDATED:
// Miscellaneous updates -- nothing to do, status update will take care of this, and is only computed for
// visible transactions.
if (inWallet && mi->second.ForceUpdate())
{
parent->beginRemoveRows(QModelIndex(), lowerIndex, upperIndex-1);
cachedWallet.erase(lower, upper);
parent->endRemoveRows();
QList<TransactionRecord> toInsert =
TransactionRecord::decomposeTransaction(wallet, mi->second);
if(!toInsert.isEmpty()) /* only if something to insert */
{
parent->beginInsertRows(QModelIndex(), lowerIndex, lowerIndex+toInsert.size()-1);
int insert_idx = lowerIndex;
foreach(const TransactionRecord &rec, toInsert)
{
cachedWallet.insert(insert_idx, rec);
insert_idx += 1;
}
int generateRingSignatureAB(data_chunk &keyImage, uint256 &txnHash, int nRingSize, int nSecretOffset, ec_secret secret, const uint8_t *pPubkeys, data_chunk &sigC, uint8_t *pSigS)
{
// https://bitcointalk.org/index.php?topic=972541.msg10619684
if (fDebugRingSig)
LogPrintf("%s: Ring size %d.\n", __func__, nRingSize);
assert(nRingSize < 200);
RandAddSeedPerfmon();
memset(pSigS, 0, EC_SECRET_SIZE * nRingSize);
int rv = 0;
int nBytes;
uint256 tmpPkHash;
uint256 tmpHash;
uint8_t tempData[66]; // hold raw point data to hash
ec_secret sAlpha;
if (0 != GenerateRandomSecret(sAlpha))
return errorN(1, "%s: GenerateRandomSecret failed.", __func__);
CHashWriter ssPkHash(SER_GETHASH, PROTOCOL_VERSION);
CHashWriter ssCjHash(SER_GETHASH, PROTOCOL_VERSION);
uint256 test;
for (int i = 0; i < nRingSize; ++i)
{
ssPkHash.write((const char*)&pPubkeys[i * EC_COMPRESSED_SIZE], EC_COMPRESSED_SIZE);
if (i == nSecretOffset)
continue;
int k;
// NOTE: necessary to clamp?
for (k = 0; k < 32; ++k)
{
if (1 != RAND_bytes(&pSigS[i * EC_SECRET_SIZE], 32))
return errorN(1, "%s: RAND_bytes ERR_get_error %u.", __func__, ERR_get_error());
memcpy(test.begin(), &pSigS[i * EC_SECRET_SIZE], 32);
if (test > MIN_SECRET && test < MAX_SECRET)
break;
};
if (k > 31)
return errorN(1, "%s: Failed to generate a valid key.", __func__);
};
tmpPkHash = ssPkHash.GetHash();
BN_CTX_start(bnCtx);
BIGNUM *bnT = BN_CTX_get(bnCtx);
BIGNUM *bnT2 = BN_CTX_get(bnCtx);
BIGNUM *bnS = BN_CTX_get(bnCtx);
BIGNUM *bnC = BN_CTX_get(bnCtx);
BIGNUM *bnCj = BN_CTX_get(bnCtx);
BIGNUM *bnA = BN_CTX_get(bnCtx);
EC_POINT *ptKi = NULL;
EC_POINT *ptPk = NULL;
EC_POINT *ptT1 = NULL;
EC_POINT *ptT2 = NULL;
EC_POINT *ptT3 = NULL;
EC_POINT *ptT4 = NULL;
if ( !(ptKi = EC_POINT_new(ecGrp))
|| !(ptPk = EC_POINT_new(ecGrp))
|| !(ptT1 = EC_POINT_new(ecGrp))
|| !(ptT2 = EC_POINT_new(ecGrp))
|| !(ptT3 = EC_POINT_new(ecGrp))
|| !(ptT4 = EC_POINT_new(ecGrp)))
{
LogPrintf("%s: EC_POINT_new failed.\n", __func__);
rv = 1; goto End;
};
// get keyimage as point
if (!EC_POINT_oct2point(ecGrp, ptKi, &keyImage[0], EC_COMPRESSED_SIZE, bnCtx))
{
LogPrintf("%s: extract ptKi failed.\n", __func__);
rv = 1; goto End;
};
// c_{j+1} = h(P_1,...,P_n,alpha*G,alpha*H(P_j))
if (!bnA || !(BN_bin2bn(&sAlpha.e[0], EC_SECRET_SIZE, bnA)))
{
LogPrintf("%s: BN_bin2bn failed.\n", __func__);
rv = 1; goto End;
};
// ptT1 = alpha * G
if (!EC_POINT_mul(ecGrp, ptT1, bnA, NULL, NULL, bnCtx))
{
LogPrintf("%s: EC_POINT_mul failed.\n", __func__);
rv = 1; goto End;
};
// ptT3 = H(Pj)
if (hashToEC(&pPubkeys[nSecretOffset * EC_COMPRESSED_SIZE], EC_COMPRESSED_SIZE, bnT2, ptT3) != 0)
{
LogPrintf("%s: hashToEC failed.\n", __func__);
rv = 1; goto End;
};
ssCjHash.write((const char*)tmpPkHash.begin(), 32);
// ptT2 = alpha * H(P_j)
// ptT2 = alpha * ptT3
if (!EC_POINT_mul(ecGrp, ptT2, NULL, ptT3, bnA, bnCtx))
{
LogPrintf("%s: EC_POINT_mul failed.\n", __func__);
rv = 1; goto End;
};
if ( !(EC_POINT_point2oct(ecGrp, ptT1, POINT_CONVERSION_COMPRESSED, &tempData[0], 33, bnCtx) == (int) EC_COMPRESSED_SIZE)
|| !(EC_POINT_point2oct(ecGrp, ptT2, POINT_CONVERSION_COMPRESSED, &tempData[33], 33, bnCtx) == (int) EC_COMPRESSED_SIZE))
{
LogPrintf("%s: extract ptL and ptR failed.\n", __func__);
rv = 1; goto End;
};
ssCjHash.write((const char*)&tempData[0], 66);
tmpHash = ssCjHash.GetHash();
if (!bnC || !(BN_bin2bn(tmpHash.begin(), EC_SECRET_SIZE, bnC)) // bnC lags i by 1
|| !BN_mod(bnC, bnC, bnOrder, bnCtx))
{
LogPrintf("%s: hash -> bnC failed.\n", __func__);
rv = 1; goto End;
};
// c_{j+2} = h(P_1,...,P_n,s_{j+1}*G+c_{j+1}*P_{j+1},s_{j+1}*H(P_{j+1})+c_{j+1}*I_j)
for (int k = 0, ib = (nSecretOffset + 1) % nRingSize, i = (nSecretOffset + 2) % nRingSize;
k < nRingSize;
++k, ib=i, i=(i+1) % nRingSize)
{
if (k == nRingSize - 1)
{
// s_j = alpha - c_j*x_j mod n.
if (!bnT || !BN_bin2bn(&secret.e[0], EC_SECRET_SIZE, bnT))
{
LogPrintf("%s: BN_bin2bn failed.\n", __func__);
rv = 1; goto End;
};
if (!BN_mul(bnT2, bnCj, bnT, bnCtx))
{
LogPrintf("%s: BN_mul failed.\n", __func__);
rv = 1; goto End;
};
if (!BN_mod_sub(bnS, bnA, bnT2, bnOrder, bnCtx))
{
LogPrintf("%s: BN_mod_sub failed.\n", __func__);
rv = 1; goto End;
};
if (!bnS || (nBytes = BN_num_bytes(bnS)) > (int) EC_SECRET_SIZE
|| BN_bn2bin(bnS, &pSigS[nSecretOffset * EC_SECRET_SIZE + (EC_SECRET_SIZE-nBytes)]) != nBytes)
{
LogPrintf("%s: bnS -> pSigS failed.\n", __func__);
rv = 1; goto End;
};
if (nSecretOffset != nRingSize - 1)
break;
};
if (!bnS || !(BN_bin2bn(&pSigS[ib * EC_SECRET_SIZE], EC_SECRET_SIZE, bnS)))
{
LogPrintf("%s: BN_bin2bn failed.\n", __func__);
rv = 1; goto End;
};
// bnC is from last round (ib)
if (!EC_POINT_oct2point(ecGrp, ptPk, &pPubkeys[ib * EC_COMPRESSED_SIZE], EC_COMPRESSED_SIZE, bnCtx))
{
LogPrintf("%s: EC_POINT_oct2point failed.\n", __func__);
rv = 1; goto End;
};
// ptT1 = s_{j+1}*G+c_{j+1}*P_{j+1}
if (!EC_POINT_mul(ecGrp, ptT1, bnS, ptPk, bnC, bnCtx))
{
LogPrintf("%s: EC_POINT_mul failed.\n", __func__);
rv = 1; goto End;
};
//s_{j+1}*H(P_{j+1})+c_{j+1}*I_j
if (hashToEC(&pPubkeys[ib * EC_COMPRESSED_SIZE], EC_COMPRESSED_SIZE, bnT2, ptT2) != 0)
{
LogPrintf("%s: hashToEC failed.\n", __func__);
rv = 1; goto End;
};
// ptT3 = s_{j+1}*H(P_{j+1})
if (!EC_POINT_mul(ecGrp, ptT3, NULL, ptT2, bnS, bnCtx))
{
LogPrintf("%s: EC_POINT_mul failed.\n", __func__);
rv = 1; goto End;
};
// ptT4 = c_{j+1}*I_j
if (!EC_POINT_mul(ecGrp, ptT4, NULL, ptKi, bnC, bnCtx))
{
LogPrintf("%s: EC_POINT_mul failed.\n", __func__);
rv = 1; goto End;
};
// ptT2 = ptT3 + ptT4
if (!EC_POINT_add(ecGrp, ptT2, ptT3, ptT4, bnCtx))
{
LogPrintf("%s: EC_POINT_add failed.\n", __func__);
rv = 1; goto End;
};
if ( !(EC_POINT_point2oct(ecGrp, ptT1, POINT_CONVERSION_COMPRESSED, &tempData[0], 33, bnCtx) == (int) EC_COMPRESSED_SIZE)
|| !(EC_POINT_point2oct(ecGrp, ptT2, POINT_CONVERSION_COMPRESSED, &tempData[33], 33, bnCtx) == (int) EC_COMPRESSED_SIZE))
{
LogPrintf("%s: extract ptL and ptR failed.\n", __func__);
rv = 1; goto End;
};
CHashWriter ssCHash(SER_GETHASH, PROTOCOL_VERSION);
ssCHash.write((const char*)tmpPkHash.begin(), 32);
ssCHash.write((const char*)&tempData[0], 66);
tmpHash = ssCHash.GetHash();
if (!bnC || !(BN_bin2bn(tmpHash.begin(), EC_SECRET_SIZE, bnC)) // bnC lags i by 1
|| !BN_mod(bnC, bnC, bnOrder, bnCtx))
{
LogPrintf("%s: hash -> bnC failed.\n", __func__);
rv = 1; goto End;
};
if (i == nSecretOffset
&& !BN_copy(bnCj, bnC))
{
LogPrintf("%s: BN_copy failed.\n", __func__);
rv = 1; goto End;
};
if (i == 0)
{
memset(tempData, 0, EC_SECRET_SIZE);
if ((nBytes = BN_num_bytes(bnC)) > (int) EC_SECRET_SIZE
|| BN_bn2bin(bnC, &tempData[0 + (EC_SECRET_SIZE-nBytes)]) != nBytes)
{
LogPrintf("%s: bnC -> sigC failed.\n", __func__);
rv = 1; goto End;
};
try { sigC.resize(32); } catch (std::exception& e)
{
LogPrintf("%s: sigC.resize failed.\n", __func__);
rv = 1; goto End;
};
memcpy(&sigC[0], tempData, EC_SECRET_SIZE);
};
};
End:
EC_POINT_free(ptKi);
EC_POINT_free(ptPk);
EC_POINT_free(ptT1);
EC_POINT_free(ptT2);
EC_POINT_free(ptT3);
EC_POINT_free(ptT4);
BN_CTX_end(bnCtx);
return rv;
};
static void InitMessage(const std::string &message)
{
LogPrintf("init message: %s\n", message);
}
int verifyRingSignatureAB(data_chunk &keyImage, uint256 &txnHash, int nRingSize, const uint8_t *pPubkeys, const data_chunk &sigC, const uint8_t *pSigS)
{
// https://bitcointalk.org/index.php?topic=972541.msg10619684
// forall_{i=1..n} compute e_i=s_i*G+c_i*P_i and E_i=s_i*H(P_i)+c_i*I_j and c_{i+1}=h(P_1,...,P_n,e_i,E_i)
// check c_{n+1}=c_1
if (fDebugRingSig)
{
//LogPrintf("%s size %d\n", __func__, nRingSize); // happens often
};
if (sigC.size() != EC_SECRET_SIZE)
return errorN(1, "%s: sigC size != EC_SECRET_SIZE.", __func__);
if (keyImage.size() != EC_COMPRESSED_SIZE)
return errorN(1, "%s: keyImage size != EC_COMPRESSED_SIZE.", __func__);
int rv = 0;
uint256 tmpPkHash;
uint256 tmpHash;
uint8_t tempData[66]; // hold raw point data to hash
CHashWriter ssPkHash(SER_GETHASH, PROTOCOL_VERSION);
CHashWriter ssCjHash(SER_GETHASH, PROTOCOL_VERSION);
for (int i = 0; i < nRingSize; ++i)
{
ssPkHash.write((const char*)&pPubkeys[i * EC_COMPRESSED_SIZE], EC_COMPRESSED_SIZE);
};
tmpPkHash = ssPkHash.GetHash();
BN_CTX_start(bnCtx);
BIGNUM *bnC = BN_CTX_get(bnCtx);
BIGNUM *bnC1 = BN_CTX_get(bnCtx);
BIGNUM *bnT = BN_CTX_get(bnCtx);
BIGNUM *bnS = BN_CTX_get(bnCtx);
EC_POINT *ptKi = NULL;
EC_POINT *ptT1 = NULL;
EC_POINT *ptT2 = NULL;
EC_POINT *ptT3 = NULL;
EC_POINT *ptPk = NULL;
EC_POINT *ptSi = NULL;
if ( !(ptKi = EC_POINT_new(ecGrp))
|| !(ptT1 = EC_POINT_new(ecGrp))
|| !(ptT2 = EC_POINT_new(ecGrp))
|| !(ptT3 = EC_POINT_new(ecGrp))
|| !(ptPk = EC_POINT_new(ecGrp))
|| !(ptSi = EC_POINT_new(ecGrp)))
{
LogPrintf("%s: EC_POINT_new failed.\n", __func__);
rv = 1; goto End;
};
// get keyimage as point
if (!EC_POINT_oct2point(ecGrp, ptKi, &keyImage[0], EC_COMPRESSED_SIZE, bnCtx))
{
LogPrintf("%s: extract ptKi failed.\n", __func__);
rv = 1; goto End;
};
if (!bnC1 || !BN_bin2bn(&sigC[0], EC_SECRET_SIZE, bnC1))
{
LogPrintf("%s: BN_bin2bn failed.\n", __func__);
rv = 1; goto End;
};
if (!BN_copy(bnC, bnC1))
{
LogPrintf("%s: BN_copy failed.\n", __func__);
rv = 1; goto End;
};
for (int i = 0; i < nRingSize; ++i)
{
if (!bnS || !(BN_bin2bn(&pSigS[i * EC_SECRET_SIZE], EC_SECRET_SIZE, bnS)))
{
LogPrintf("%s: BN_bin2bn failed.\n", __func__);
rv = 1; goto End;
};
// ptT2 <- pk
if (!EC_POINT_oct2point(ecGrp, ptPk, &pPubkeys[i * EC_COMPRESSED_SIZE], EC_COMPRESSED_SIZE, bnCtx))
{
LogPrintf("%s: EC_POINT_oct2point failed.\n", __func__);
rv = 1; goto End;
};
// ptT1 = e_i=s_i*G+c_i*P_i
if (!EC_POINT_mul(ecGrp, ptT1, bnS, ptPk, bnC, bnCtx))
{
LogPrintf("%s: EC_POINT_mul failed.\n", __func__);
rv = 1; goto End;
};
if (!(EC_POINT_point2oct(ecGrp, ptT1, POINT_CONVERSION_COMPRESSED, &tempData[0], 33, bnCtx) == (int) EC_COMPRESSED_SIZE))
{
LogPrintf("%s: extract ptT1 failed.\n", __func__);
rv = 1; goto End;
};
// ptT2 =E_i=s_i*H(P_i)+c_i*I_j
// ptT2 =H(P_i)
if (hashToEC(&pPubkeys[i * EC_COMPRESSED_SIZE], EC_COMPRESSED_SIZE, bnT, ptT2) != 0)
{
LogPrintf("%s: hashToEC failed.\n", __func__);
rv = 1; goto End;
};
// DEBUGGING: ------- check if we can find the signer...
// ptSi = Pi * bnT
if ((!EC_POINT_mul(ecGrp, ptSi, NULL, ptPk, bnT, bnCtx)
|| false)
&& (rv = errorN(1, "%s: EC_POINT_mul failed.", __func__)))
goto End;
if (0 == EC_POINT_cmp(ecGrp, ptSi, ptKi, bnCtx) )
LogPrintf("signer is index %d\n", i);
// DEBUGGING: - End - check if we can find the signer...
// ptT3 = s_i*ptT2
if (!EC_POINT_mul(ecGrp, ptT3, NULL, ptT2, bnS, bnCtx))
{
LogPrintf("%s: EC_POINT_mul failed.\n", __func__);
rv = 1; goto End;
};
// ptT1 = c_i*I_j
if (!EC_POINT_mul(ecGrp, ptT1, NULL, ptKi, bnC, bnCtx))
{
LogPrintf("%s: EC_POINT_mul failed.\n", __func__);
rv = 1; goto End;
};
// ptT2 = ptT3 + ptT1
if (!EC_POINT_add(ecGrp, ptT2, ptT3, ptT1, bnCtx))
{
LogPrintf("%s: EC_POINT_add failed.\n", __func__);
rv = 1; goto End;
};
if (!(EC_POINT_point2oct(ecGrp, ptT2, POINT_CONVERSION_COMPRESSED, &tempData[33], 33, bnCtx) == (int) EC_COMPRESSED_SIZE))
{
LogPrintf("%s: extract ptT2 failed.\n", __func__);
rv = 1; goto End;
};
CHashWriter ssCHash(SER_GETHASH, PROTOCOL_VERSION);
ssCHash.write((const char*)tmpPkHash.begin(), 32);
ssCHash.write((const char*)&tempData[0], 66);
tmpHash = ssCHash.GetHash();
if (!bnC || !(BN_bin2bn(tmpHash.begin(), EC_SECRET_SIZE, bnC))
|| !BN_mod(bnC, bnC, bnOrder, bnCtx))
{
LogPrintf("%s: tmpHash -> bnC failed.\n", __func__);
rv = 1; goto End;
};
};
// bnT = (bnC - bnC1) % N
if (!BN_mod_sub(bnT, bnC, bnC1, bnOrder, bnCtx))
{
LogPrintf("%s: BN_mod_sub failed.\n", __func__);
rv = 1; goto End;
};
// test bnT == 0 (bnC == bnC1)
if (!BN_is_zero(bnT))
{
LogPrintf("%s: signature does not verify.\n", __func__);
rv = 2;
};
End:
BN_CTX_end(bnCtx);
EC_POINT_free(ptKi);
EC_POINT_free(ptT1);
EC_POINT_free(ptT2);
EC_POINT_free(ptT3);
EC_POINT_free(ptPk);
EC_POINT_free(ptSi);
return rv;
};
int generateRingSignature(data_chunk &keyImage, uint256 &txnHash, int nRingSize, int nSecretOffset, ec_secret secret, const uint8_t *pPubkeys, uint8_t *pSigc, uint8_t *pSigr)
{
if (fDebugRingSig)
LogPrintf("%s: Ring size %d.\n", __func__, nRingSize);
int rv = 0;
int nBytes;
BN_CTX_start(bnCtx);
BIGNUM *bnKS = BN_CTX_get(bnCtx);
BIGNUM *bnK1 = BN_CTX_get(bnCtx);
BIGNUM *bnK2 = BN_CTX_get(bnCtx);
BIGNUM *bnT = BN_CTX_get(bnCtx);
BIGNUM *bnH = BN_CTX_get(bnCtx);
BIGNUM *bnSum = BN_CTX_get(bnCtx);
EC_POINT *ptT1 = NULL;
EC_POINT *ptT2 = NULL;
EC_POINT *ptT3 = NULL;
EC_POINT *ptPk = NULL;
EC_POINT *ptKi = NULL;
EC_POINT *ptL = NULL;
EC_POINT *ptR = NULL;
uint8_t tempData[66]; // hold raw point data to hash
uint256 commitHash;
ec_secret scData1, scData2;
CHashWriter ssCommitHash(SER_GETHASH, PROTOCOL_VERSION);
ssCommitHash << txnHash;
// zero signature
memset(pSigc, 0, EC_SECRET_SIZE * nRingSize);
memset(pSigr, 0, EC_SECRET_SIZE * nRingSize);
// ks = random 256 bit int mod P
if (GenerateRandomSecret(scData1)
&& (rv = errorN(1, "%s: GenerateRandomSecret failed.", __func__)))
goto End;
if (!bnKS || !(BN_bin2bn(&scData1.e[0], EC_SECRET_SIZE, bnKS)))
{
LogPrintf("%s: BN_bin2bn failed.\n", __func__);
rv = 1; goto End;
};
// zero sum
if (!bnSum || !(BN_zero(bnSum)))
{
LogPrintf("%s: BN_zero failed.\n", __func__);
rv = 1; goto End;
};
if ( !(ptT1 = EC_POINT_new(ecGrp))
|| !(ptT2 = EC_POINT_new(ecGrp))
|| !(ptT3 = EC_POINT_new(ecGrp))
|| !(ptPk = EC_POINT_new(ecGrp))
|| !(ptKi = EC_POINT_new(ecGrp))
|| !(ptL = EC_POINT_new(ecGrp))
|| !(ptR = EC_POINT_new(ecGrp)))
{
LogPrintf("%s: EC_POINT_new failed.\n", __func__);
rv = 1; goto End;
};
// get keyimage as point
if (!(bnT = BN_bin2bn(&keyImage[0], EC_COMPRESSED_SIZE, bnT))
|| !(ptKi) || !(ptKi = EC_POINT_bn2point(ecGrp, bnT, ptKi, bnCtx)))
{
LogPrintf("%s: extract ptKi failed.\n", __func__);
rv = 1; goto End;
};
for (int i = 0; i < nRingSize; ++i)
{
if (i == nSecretOffset)
{
// k = random 256 bit int mod P
// L = k * G
// R = k * HashToEC(PKi)
if (!EC_POINT_mul(ecGrp, ptL, bnKS, NULL, NULL, bnCtx))
{
LogPrintf("%s: EC_POINT_mul failed.\n", __func__);
rv = 1; goto End;
};
if (hashToEC(&pPubkeys[i * EC_COMPRESSED_SIZE], EC_COMPRESSED_SIZE, bnT, ptT1) != 0)
{
LogPrintf("%s: hashToEC failed.\n", __func__);
rv = 1; goto End;
};
if (!EC_POINT_mul(ecGrp, ptR, NULL, ptT1, bnKS, bnCtx))
{
LogPrintf("%s: EC_POINT_mul failed.\n", __func__);
rv = 1; goto End;
};
} else
{
// k1 = random 256 bit int mod P
// k2 = random 256 bit int mod P
// Li = k1 * Pi + k2 * G
// Ri = k1 * I + k2 * Hp(Pi)
// ci = k1
// ri = k2
if (GenerateRandomSecret(scData1) != 0
|| !bnK1 || !(BN_bin2bn(&scData1.e[0], EC_SECRET_SIZE, bnK1))
|| GenerateRandomSecret(scData2) != 0
|| !bnK2 || !(BN_bin2bn(&scData2.e[0], EC_SECRET_SIZE, bnK2)))
{
LogPrintf("%s: k1 and k2 failed.\n", __func__);
rv = 1; goto End;
};
// get Pk i as point
if (!(bnT = BN_bin2bn(&pPubkeys[i * EC_COMPRESSED_SIZE], EC_COMPRESSED_SIZE, bnT))
|| !(ptPk) || !(ptPk = EC_POINT_bn2point(ecGrp, bnT, ptPk, bnCtx)))
{
LogPrintf("%s: extract ptPk failed.\n", __func__);
rv = 1; goto End;
};
// ptT1 = k1 * Pi
if (!EC_POINT_mul(ecGrp, ptT1, NULL, ptPk, bnK1, bnCtx))
{
LogPrintf("%s: EC_POINT_mul failed.\n", __func__);
rv = 1; goto End;
};
// ptT2 = k2 * G
if (!EC_POINT_mul(ecGrp, ptT2, bnK2, NULL, NULL, bnCtx))
{
LogPrintf("%s: EC_POINT_mul failed.\n", __func__);
rv = 1; goto End;
};
// ptL = ptT1 + ptT2
if (!EC_POINT_add(ecGrp, ptL, ptT1, ptT2, bnCtx))
{
LogPrintf("%s: EC_POINT_add failed.\n", __func__);
rv = 1; goto End;
};
// ptT3 = Hp(Pi)
if (hashToEC(&pPubkeys[i * EC_COMPRESSED_SIZE], EC_COMPRESSED_SIZE, bnT, ptT3) != 0)
{
LogPrintf("%s: hashToEC failed.\n", __func__);
rv = 1; goto End;
};
// ptT1 = k1 * I
if (!EC_POINT_mul(ecGrp, ptT1, NULL, ptKi, bnK1, bnCtx))
{
LogPrintf("%s: EC_POINT_mul failed.\n", __func__);
rv = 1; goto End;
};
// ptT2 = k2 * ptT3
if (!EC_POINT_mul(ecGrp, ptT2, NULL, ptT3, bnK2, bnCtx))
{
LogPrintf("%s: EC_POINT_mul failed.\n", __func__);
rv = 1; goto End;
};
// ptR = ptT1 + ptT2
if (!EC_POINT_add(ecGrp, ptR, ptT1, ptT2, bnCtx))
{
LogPrintf("%s: EC_POINT_add failed.\n", __func__);
rv = 1; goto End;
};
memcpy(&pSigc[i * EC_SECRET_SIZE], &scData1.e[0], EC_SECRET_SIZE);
memcpy(&pSigr[i * EC_SECRET_SIZE], &scData2.e[0], EC_SECRET_SIZE);
// sum = (sum + sigc) % N , sigc == bnK1
if (!BN_mod_add(bnSum, bnSum, bnK1, bnOrder, bnCtx))
{
LogPrintf("%s: BN_mod_add failed.\n", __func__);
rv = 1; goto End;
};
};
// -- add ptL and ptR to hash
if ( !(EC_POINT_point2oct(ecGrp, ptL, POINT_CONVERSION_COMPRESSED, &tempData[0], 33, bnCtx) == (int) EC_COMPRESSED_SIZE)
|| !(EC_POINT_point2oct(ecGrp, ptR, POINT_CONVERSION_COMPRESSED, &tempData[33], 33, bnCtx) == (int) EC_COMPRESSED_SIZE))
{
LogPrintf("%s: extract ptL and ptR failed.\n", __func__);
rv = 1; goto End;
};
ssCommitHash.write((const char*)&tempData[0], 66);
};
commitHash = ssCommitHash.GetHash();
if (!(bnH) || !(bnH = BN_bin2bn(commitHash.begin(), EC_SECRET_SIZE, bnH)))
{
LogPrintf("%s: commitHash -> bnH failed.\n", __func__);
rv = 1; goto End;
};
if (!BN_mod(bnH, bnH, bnOrder, bnCtx)) // this is necessary
{
LogPrintf("%s: BN_mod failed.\n", __func__);
rv = 1; goto End;
};
// sigc[nSecretOffset] = (bnH - bnSum) % N
if (!BN_mod_sub(bnT, bnH, bnSum, bnOrder, bnCtx))
{
LogPrintf("%s: BN_mod_sub failed.\n", __func__);
rv = 1; goto End;
};
if ((nBytes = BN_num_bytes(bnT)) > (int)EC_SECRET_SIZE
|| BN_bn2bin(bnT, &pSigc[nSecretOffset * EC_SECRET_SIZE + (EC_SECRET_SIZE-nBytes)]) != nBytes)
{
LogPrintf("%s: bnT -> pSigc failed.\n", __func__);
rv = 1; goto End;
};
// sigr[nSecretOffset] = (bnKS - sigc[nSecretOffset] * bnSecret) % N
// reuse bnH for bnSecret
if (!bnH || !(BN_bin2bn(&secret.e[0], EC_SECRET_SIZE, bnH)))
{
LogPrintf("%s: BN_bin2bn failed.\n", __func__);
rv = 1; goto End;
};
// bnT = sigc[nSecretOffset] * bnSecret , TODO: mod N ?
if (!BN_mul(bnT, bnT, bnH, bnCtx))
{
LogPrintf("%s: BN_mul failed.\n", __func__);
rv = 1; goto End;
};
if (!BN_mod_sub(bnT, bnKS, bnT, bnOrder, bnCtx))
{
LogPrintf("%s: BN_mod_sub failed.\n", __func__);
rv = 1; goto End;
};
if ((nBytes = BN_num_bytes(bnT)) > (int) EC_SECRET_SIZE
|| BN_bn2bin(bnT, &pSigr[nSecretOffset * EC_SECRET_SIZE + (EC_SECRET_SIZE-nBytes)]) != nBytes)
{
LogPrintf("%s: bnT -> pSigr failed.\n", __func__);
rv = 1; goto End;
};
End:
EC_POINT_free(ptT1);
EC_POINT_free(ptT2);
EC_POINT_free(ptT3);
EC_POINT_free(ptPk);
EC_POINT_free(ptKi);
EC_POINT_free(ptL);
EC_POINT_free(ptR);
BN_CTX_end(bnCtx);
return rv;
};
//+---------------------------------------------------------------------------
//
// Function: HrShowNetAdapters
//
// Purpose: Display all installed net class devices using Setup API
//
// Arguments: None
//
// Returns: S_OK on success, otherwise an error code
//
// Notes:
//
HRESULT HrShowNetAdapters()
{
#define MAX_COMP_INSTID 4096
#define MAX_COMP_DESC 4096
HRESULT hr=S_OK;
HDEVINFO hdi;
DWORD dwIndex=0;
SP_DEVINFO_DATA deid;
BOOL fSuccess=FALSE;
DWORD cchRequiredSize;
TCHAR szCompInstanceId[MAX_COMP_INSTID];
TCHAR szCompDescription[MAX_COMP_DESC];
DWORD dwRegType;
BOOL fFound=FALSE;
// get a list of all devices of class 'GUID_DEVCLASS_NET'
hdi = SetupDiGetClassDevs(&GUID_DEVCLASS_NET, NULL, NULL, DIGCF_PRESENT);
if (INVALID_HANDLE_VALUE != hdi)
{
// enumerate over each device
while (deid.cbSize = sizeof(SP_DEVINFO_DATA),
SetupDiEnumDeviceInfo(hdi, dwIndex, &deid))
{
dwIndex++;
// the right thing to do here would be to call this function
// to get the size required to hold the instance ID and then
// to call it second time with a buffer large enough for that size.
// However, that would tend to obscure the control flow in
// the sample code. Lets keep things simple by keeping the
// buffer large enough.
// get the device instance ID
fSuccess = SetupDiGetDeviceInstanceId(hdi, &deid,
szCompInstanceId,
MAX_COMP_INSTID, NULL);
if (fSuccess)
{
// get the description for this instance
fSuccess =
SetupDiGetDeviceRegistryProperty(hdi, &deid,
SPDRP_DEVICEDESC,
&dwRegType,
(BYTE*) szCompDescription,
MAX_COMP_DESC,
NULL);
if (fSuccess)
{
if (!fFound)
{
fFound = TRUE;
LogPrintf(_T("Instance ID\tDescription\n"));
LogPrintf(_T("-----------\t-----------\n"));
}
LogPrintf(_T("%s\t%s\n"),
szCompInstanceId, szCompDescription);
}
}
}
// release the device info list
SetupDiDestroyDeviceInfoList(hdi);
}
if (!fSuccess)
{
DWORD dwError = GetLastError();
hr = HRESULT_FROM_WIN32(dwError);
}
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: HrShowBindingPath
//
// Purpose: Display components of a binding path in the format:
// foo -> bar -> adapter
//
// Arguments:
// pncbp [in] pointer to INetCfgBindingPath object
//
// Returns: S_OK on success, otherwise an error code
//
// Notes:
//
HRESULT HrShowBindingPath(IN INetCfgBindingPath* pncbp)
{
HRESULT hr=S_OK;
INetCfgBindingInterface* pncbi;
INetCfgComponent* pncc = NULL;
BOOL fFirstInterface=TRUE;
PWSTR szComponentId;
while (SUCCEEDED(hr) &&
(S_OK == (hr = HrGetNextBindingInterface(pncbp, &pncbi))))
{
// for the first (top) interface we need to get the upper as well as
// the lower component. for other interfaces we need to get
// only the lower component.
if (fFirstInterface)
{
fFirstInterface = FALSE;
hr = pncbi->GetUpperComponent(&pncc);
if (SUCCEEDED(hr))
{
// get id so that we can display it
//
// for readability of the output, we have used the GetId
// function. For non net class components, this
// does not pose a problem. In case of net class components,
// there may be more than one net adapters of the same type
// in which case, GetId will return the same string. This will
// make it impossible to distinguish between two binding
// paths that end in two distinct identical cards. In such case,
// it may be better to use the GetInstanceGuid function because
// it will return unique GUID for each instance of an adapter.
//
hr = pncc->GetId(&szComponentId);
ReleaseObj(pncc);
if (SUCCEEDED(hr))
{
// LogPrintf(szComponentId);
CoTaskMemFree(szComponentId);
}
}
}
if (SUCCEEDED(hr))
{
hr = pncbi->GetLowerComponent(&pncc);
if (SUCCEEDED(hr))
{
hr = pncc->GetId(&szComponentId);
if (SUCCEEDED(hr))
{
LogPrintf(_T(" -> %s"), szComponentId);
CoTaskMemFree(szComponentId);
}
ReleaseObj(pncc);
}
}
ReleaseObj(pncbi);
}
LogPrintf(_T("\n"));
if (hr == S_FALSE)
{
hr = S_OK;
}
return hr;
}
int CaptDisMain(int argc, char *argv[])
{
char ifile[RLTM_POL_PATH_DIM];
char dirpath[RLTM_POL_PATH_DIM];
char tmp[RLTM_POL_PATH_DIM];
char errbuf[PCAP_ERRBUF_SIZE];
char intrf[RLTM_POL_PATH_DIM], filter_app[RLTM_POL_PATH_DIM];
struct bpf_program filter; /* The compiled filter */
pcap_t *cap = NULL;
char *param;
int ret;
struct pcap_ref ref;
FILE *fp;
bool end, ses_id, pol_id;
struct pcap_pkthdr *pkt_header;
const u_char *pkt_data;
static time_t tm = 0;
struct pcap_file_header fh;
end = FALSE;
ses_id = FALSE;
pol_id = FALSE;
savepcap = 0;
/* pcapfile protocol id */
pol_prot_id = ProtId("pol");
if (pol_prot_id == -1) {
return -1;
}
/* serial number of packet */
pkt_serial = 1;
/* interace & filter % pol dir name*/
intrf[0] = '\0';
filter_app[0] = '\0';
dirpath[0] = '\0';
ret = RltmPolParam(argc, argv, intrf, filter_app, dirpath);
if (ret != 0) {
return -1;
}
/* check name dir */
if (dirpath[0] == '\0') {
return -1;
}
/* read pol info */
sprintf(ifile, "%s/%s", dirpath, RLTM_POL_INIT_SESSION_FILE);
fp = fopen(ifile, "r");
if (fp == NULL) {
LogPrintf(LV_ERROR, "Pol info file (%s) not present!", ifile);
return -1;
}
while (fgets(tmp, CFG_LINE_MAX_SIZE, fp) != NULL) {
/* check if line is a comment */
if (!CfgParIsComment(tmp)) {
param = strstr(tmp, RLTM_POL_SESSION_ID);
if (param != NULL) {
ret = sscanf(param, RLTM_POL_SESSION_ID"=%lu", &ref.ses_id);
if (ret == 1) {
ses_id = TRUE;
}
}
param = strstr(tmp, RLTM_POL_ID);
if (param != NULL) {
ret = sscanf(param, RLTM_POL_ID"=%lu", &ref.pol_id);
if (ret == 1) {
pol_id = TRUE;
}
}
}
}
fclose(fp);
remove(ifile);
if (ses_id == FALSE || pol_id == FALSE) {
LogPrintf(LV_ERROR, "Pol info file (%s) incomplete!", tmp);
return -1;
}
errbuf[sizeof(errbuf) - 1] = '\0';
errbuf[0] = '\0';
/* open device in promiscuous mode */
#ifdef HAVE_PCAP_CREATE
cap = pcap_create(intrf, errbuf);
#else
cap = pcap_open_live(intrf, 102400, 1, 0, errbuf);
#endif
if (cap == NULL) {
printf("Error: %s\n", errbuf);
return -1;
}
else {
#ifdef HAVE_PCAP_CREATE
ret = pcap_set_snaplen(cap, 102400);
if (ret != 0) {
printf("You have an old version of libpcap\n");
return -1;
}
ret = pcap_set_promisc(cap, 1);
if (ret != 0) {
printf("You have an old version of libpcap\n");
return -1;
}
ret = pcap_set_timeout(cap, 0);
if (ret != 0) {
printf("You have an old version of libpcap\n");
return -1;
}
/* set capture buffer size to 16 MB */
ret = pcap_set_buffer_size(cap, (1<<24));
if (ret != 0) {
printf("You have an old version of libpcap\n");
return -1;
}
ret = pcap_activate(cap);
if (ret != 0) {
printf("pcap_activate failed '%s'\n", pcap_geterr(cap));
return -1;
}
#endif
/* compile and apply the filter */
if (pcap_compile(cap, &filter, filter_app, 1, 0) < 0) {
printf("Bad filter %s\n", filter_app);
pcap_perror(cap, "Filter");
return -1;
}
pcap_setfilter(cap, &filter);
pcap_freecode(&filter);
/* interface */
ref.dev = intrf;
/* data link type */
ref.dlt = pcap_datalink(cap);
/* packet counter */
ref.cnt = 0;
/* end filename */
sprintf(ifile, "%s/%s", dirpath, RLTM_POL_END_SESSION_FILE);
if (savepcap) {
/* pcap file for debug */
sprintf(pcap_deb, "/opt/xplico/pol_%li/sol_%li/raw/interface_%s_%lu.pcap", ref.pol_id, ref.ses_id, intrf, time(NULL));
fp_pcap = fopen(pcap_deb, "w");
crash_ref_name = pcap_deb;
memset(&fh, 0, sizeof(struct pcap_file_header));
fh.magic = 0xA1B2C3D4;
fh.version_major = PCAP_VERSION_MAJOR;
fh.version_minor = PCAP_VERSION_MINOR;
fh.snaplen = 65535;
fh.linktype = ref.dlt;
if (fp_pcap != NULL) {
fwrite((char *)&fh, 1, sizeof(struct pcap_file_header), fp_pcap);
}
else {
LogPrintf(LV_ERROR, "Debug raw file failed: %s", pcap_deb);
sprintf(pcap_deb, "Real Time");
}
}
else {
fp_pcap = NULL;
}
do {
/* read data */
if (pcap_next_ex(cap, &pkt_header, &pkt_data) == -1) {
/* exit */
break;
}
else {
/* decode data */
RltmPolDissector((u_char *)&ref, pkt_header, pkt_data);
}
/* check the end */
if (time(NULL) > tm) {
tm = time(NULL) + 1;
fp = fopen(ifile, "r");
if (fp != NULL) {
end = TRUE;
fclose(fp);
}
}
} while (end == FALSE);
pcap_close(cap);
/* remove file */
remove(ifile);
}
if (fp_pcap != NULL)
fclose(fp_pcap);
return 0;
}
bool OsmAnd::ResolvedMapStyle_P::mergeAndResolveRulesets()
{
const auto builtinValueDefs = MapStyleBuiltinValueDefinitions::get();
for (auto rulesetTypeIdx = 0u; rulesetTypeIdx < MapStyleRulesetTypesCount; rulesetTypeIdx++)
{
QHash<TagValueId, std::shared_ptr<Rule> > ruleset;
// Process styles chain in direct order. This will allow to process overriding correctly
auto citUnresolvedMapStyle = iteratorOf(owner->unresolvedMapStylesChain);
while (citUnresolvedMapStyle.hasNext())
{
const auto& unresolvedMapStyle = citUnresolvedMapStyle.next();
const auto& unresolvedRuleset = unresolvedMapStyle->rulesets[rulesetTypeIdx];
auto itUnresolvedByTag = iteratorOf(unresolvedRuleset);
while (itUnresolvedByTag.hasNext())
{
const auto& unresolvedByTagEntry = itUnresolvedByTag.next();
const auto& tag = unresolvedByTagEntry.key();
const auto& unresolvedByTag = unresolvedByTagEntry.value();
const auto tagId = resolveStringIdInLUT(tag);
auto itUnresolvedByValue = iteratorOf(unresolvedByTag);
while (itUnresolvedByValue.hasNext())
{
const auto& unresolvedByValueEntry = itUnresolvedByValue.next();
const auto& value = unresolvedByValueEntry.key();
const auto& unresolvedRule = unresolvedByValueEntry.value();
const auto valueId = resolveStringIdInLUT(value);
const auto tagValueId = TagValueId::compose(tagId, valueId);
auto& topLevelRule = ruleset[tagValueId];
// Create top-level rule if not yet created
if (!topLevelRule)
{
topLevelRule.reset(new Rule(static_cast<MapStyleRulesetType>(rulesetTypeIdx)));
topLevelRule->rootNode->values[builtinValueDefs->id_INPUT_TAG] =
ResolvedValue::fromConstantValue(MapStyleConstantValue::fromSimpleUInt(tagId));
topLevelRule->rootNode->values[builtinValueDefs->id_INPUT_VALUE] =
ResolvedValue::fromConstantValue(MapStyleConstantValue::fromSimpleUInt(valueId));
}
const auto resolvedRuleNode = resolveRuleNode(unresolvedRule->rootNode);
if (!resolvedRuleNode)
{
LogPrintf(LogSeverityLevel::Warning,
"One of rules for '%s':'%s' was ignored due to failure to resolve it",
qPrintable(tag),
qPrintable(value));
return false;
}
topLevelRule->rootNode->oneOfConditionalSubnodes.append(resolvedRuleNode->oneOfConditionalSubnodes);
}
}
_rulesets[rulesetTypeIdx] = copyAs< TagValueId, std::shared_ptr<const Rule> >(ruleset);
}
}
return true;
}
void ManageNamesPage::on_submitNameButton_clicked()
{
if (!walletModel)
return;
QString name = ui->registerName->text();
bool avail = walletModel->nameAvailable(name);
if (!avail)
{
QMessageBox::warning(this, tr("Name registration"), tr("Name not available"));
ui->registerName->setFocus();
return;
}
QString msg;
if (name.startsWith("d/"))
msg = tr("Are you sure you want to register domain name %1, which "
"corresponds to domain %2? <br><br> NOTE: If your wallet is locked, you will be prompted "
"to unlock it in 12 blocks.").arg(name).arg(name.mid(2) + ".bit");
else
msg = tr("Are you sure you want to register non-domain name %1? <br><br>"
"NOTE: If your wallet is locked, you will be prompted "
"to unlock it in 12 blocks.").arg(name);
if (QMessageBox::Yes != QMessageBox::question(this, tr("Confirm name registration"),
msg,
QMessageBox::Yes | QMessageBox::Cancel,
QMessageBox::Cancel))
{
return;
}
WalletModel::UnlockContext ctx(walletModel->requestUnlock());
if (!ctx.isValid())
return;
QString err_msg;
std::string strName = name.toStdString();
try
{
NameNewReturn res = walletModel->nameNew(name);
if (res.ok)
{
// save pending name firstupdate data ... this gets
// picked up after the config name dialog is accepted
pendingNameFirstUpdate[strName] = res;
// reset UI text
ui->registerName->setText("d/");
ui->submitNameButton->setDefault(true);
int newRowIndex;
// FIXME: CT_NEW may have been sent from nameNew (via transaction).
// Currently updateEntry is modified so it does not complain
model->updateEntry(name, "", NameTableEntry::NAME_NEW, CT_NEW, &newRowIndex);
ui->tableView->selectRow(newRowIndex);
ui->tableView->setFocus();
ConfigureNameDialog dlg(platformStyle, name, "", true, this);
dlg.setModel(walletModel);
if (dlg.exec() == QDialog::Accepted)
{
LOCK(cs_main);
if (pendingNameFirstUpdate.count(strName) != 0)
{
model->updateEntry(name, dlg.getReturnData(), NameTableEntry::NAME_NEW, CT_UPDATED);
}
else
{
// name_firstupdate could have been sent, while the user was editing the value
// Do nothing
}
}
return;
}
err_msg = QString(res.err_msg.c_str());
}
catch (std::exception& e)
{
err_msg = e.what();
LogPrintf("ManageNamesPage::on_submitNameButton_clicked; %s", err_msg.toStdString().c_str());
}
if (err_msg == "ABORTED")
return;
QMessageBox::warning(this, tr("Name registration failed"), err_msg);
}
static void RltmPolDissector(u_char *user, const struct pcap_pkthdr *h, const u_char *bytes)
{
struct pcap_ref *ref = (struct pcap_ref *)user;
packet *pkt;
static time_t tm = 0;
int offset;
struct timespec to;
struct pcap_pkthdr pckt_header;
size_t nwrt, wcnt;
pkt = PktNew();
ref->cnt++;
pkt->raw = DMemMalloc(h->caplen+sizeof(unsigned long)*2+sizeof(char *)+sizeof(unsigned long)*2);
memcpy(pkt->raw, bytes, h->caplen);
pkt->raw_len = h->caplen;
offset = 0;
*((unsigned long *)&(pkt->raw[pkt->raw_len])) = ref->dlt;
offset += sizeof(unsigned long);
*((unsigned long *)&(pkt->raw[pkt->raw_len+offset])) = ref->cnt;
offset += sizeof(unsigned long);
if (savepcap)
*((char **)&(pkt->raw[pkt->raw_len+offset])) = pcap_deb;
else
*((char **)&(pkt->raw[pkt->raw_len+offset])) = "Real Time";
offset += sizeof(char *);
*((unsigned long *)&(pkt->raw[pkt->raw_len+offset])) = ref->ses_id;
offset += sizeof(unsigned long);
*((unsigned long *)&(pkt->raw[pkt->raw_len+offset])) = ref->pol_id;
pkt->cap_sec = h->ts.tv_sec;
pkt->cap_usec = h->ts.tv_usec;
pkt->serial = pkt_serial;
/* crash info */
crash_pkt_cnt = ref->cnt;
/* decode */
/* save packet */
if (fp_pcap != NULL) {
pckt_header.caplen = pkt->raw_len;
pckt_header.len = pkt->raw_len;
pckt_header.ts.tv_sec = pkt->cap_sec;
pckt_header.ts.tv_usec = pkt->cap_usec;
wcnt = 0;
do {
nwrt = fwrite(((char *)&pckt_header)+wcnt, 1, sizeof(struct pcap_pkthdr)-wcnt, fp_pcap);
if (nwrt != -1)
wcnt += nwrt;
else
break;
} while (wcnt != sizeof(struct pcap_pkthdr));
wcnt = 0;
do {
nwrt = fwrite(((char *)pkt->raw)+wcnt, 1, pkt->raw_len-wcnt, fp_pcap);
if (nwrt != -1)
wcnt += nwrt;
else
break;
} while (wcnt != pkt->raw_len);
}
ProtDissec(pol_prot_id, pkt);
FlowSetGblTime(h->ts.tv_sec);
/* next serial number */
pkt_serial++;
if (time(NULL) > tm) {
tm = time(NULL) + 5;
ReportSplash();
while (DispatchPeiPending() > DISP_PEI_MAX_QUEUE) {
to.tv_sec = 2;
to.tv_nsec = 1;
/* wait some time */
while (nanosleep(&to, &to) != 0)
;
LogPrintf(LV_WARNING, "Possible data loss!");
ReportSplash();
}
}
}
static packet *TelnetDissector(int flow_id)
{
packet *pkt;
const pstack_f *tcp, *ip;
ftval lost, ip_host, port;
unsigned short port_host;
bool ipv6;
long offset, len, size;
char host[TELNET_FILENAME_PATH_SIZE];
char user[TELNET_BUF_SIZE];
char password[TELNET_BUF_SIZE];
char cmd_file[TELNET_FILENAME_PATH_SIZE];
FILE *fp;
char *buf;
pei *ppei;
time_t cap_sec, end_cap;
int cntpkt;
LogPrintf(LV_DEBUG, "Telnet id: %d", flow_id);
cntpkt = 0;
/* init (this for each telnet stream) */
user[0] = '\0';
password[0] = '\0';
sprintf(cmd_file, "%s/%s/telnet_%lu_%p_%i.txt", ProtTmpDir(), TELNET_TMP_DIR, time(NULL), cmd_file, incr);
incr++;
fp = fopen(cmd_file, "w");
ipv6 = FALSE;
buf = DMemMalloc(TELNET_LOGIN_SIZE);
buf[0] = '\0';
len = 0;
/* ip version and number */
tcp = FlowStack(flow_id); /* tcp frame */
ip = ProtGetNxtFrame(tcp); /* ip/ipv6 frame */
ProtGetAttr(tcp, port_dst_id, &port);
port_host = port.uint16;
if (ProtFrameProtocol(ip) == ipv6_id) {
ipv6 = TRUE;
}
if (ipv6 == FALSE) {
ProtGetAttr(ip, ip_dst_id, &ip_host);
if (DnsDbSearch(&(ip_host), FT_IPv4, host, TELNET_FILENAME_PATH_SIZE) != 0) {
FTString(&(ip_host), FT_IPv4, host);
}
}
else {
ProtGetAttr(ip, ipv6_dst_id, &ip_host);
if (DnsDbSearch(&(ip_host), FT_IPv6, host, TELNET_FILENAME_PATH_SIZE) != 0) {
FTString(&(ip_host), FT_IPv6, host);
}
}
sprintf(host+strlen(host), ":%i", port_host);
/* first packet */
pkt = FlowGetPkt(flow_id);
if (pkt != NULL) {
/* pei definition */
PeiNew(&ppei, telnet_id);
PeiCapTime(ppei, pkt->cap_sec);
PeiMarker(ppei, pkt->serial);
PeiStackFlow(ppei, tcp);
cap_sec = pkt->cap_sec;
}
while (pkt != NULL) {
cntpkt++;
end_cap = pkt->cap_sec;
offset = 0;
/* check if there are packet lost */
ProtGetAttr(pkt->stk, lost_id, &lost);
//ProtStackFrmDisp(pkt->stk, TRUE); /* this function display the structure of packet stack of this packet */
if (lost.uint8 == FALSE && pkt->len != 0) {
/* no packet lost and packet with data */
/* skip the telnet commands, we are interested only in readable data */
#warning "to do: reassemble telnet message from many tcp packets"
offset = TelnetSkipCommand((unsigned char *)(pkt->data), (unsigned char *)(pkt->data + pkt->len));
if (offset < pkt->len) {
TelnetConvertZeros((unsigned char *)(pkt->data + offset), (unsigned char *)(pkt->data + pkt->len));
size = pkt->len - offset;
fwrite(pkt->data + offset, 1, size, fp);
if (len + size < TELNET_LOGIN_SIZE) {
memcpy(buf+len, pkt->data + offset, size);
len += size;
buf[len] = '\0';
}
}
}
else if (lost.uint8) {
fprintf(fp, "-----> xplico: packets lost (size: %lub) <-----", pkt->len);
}
/* new/next packet */
PktFree(pkt);
pkt = FlowGetPkt(flow_id);
}
/* search login */
buf[TELNET_LOGIN_SIZE - 1] = '\0';
TelnetLogin(buf, user, password, TELNET_BUF_SIZE);
/* free memory and close file */
DMemFree(buf);
if (fp != NULL) {
fclose(fp);
}
if (len != 0) {
/* compose pei */
TelnetPei(ppei, host, user, password, cmd_file, &cap_sec, &end_cap);
/* insert pei */
PeiIns(ppei);
}
LogPrintf(LV_DEBUG, "Telnet... bye bye. (count:%i)", cntpkt);
return NULL;
}
static int TelnetLogin(char *buf, char *user, char *pswd, int bsize)
{
char *tmp, *lgn;
long size, i;
lgn = strcasestr(buf, "login:"******"login:"******"Password:"******"user name error: %s", lgn);
size = bsize - 1;
}
memcpy(user, lgn, size);
user[size] = '\0';
/* password */
lgn = strcasestr(lgn, "Password:"******"password error: %s", lgn);
size = bsize - 1;
}
memcpy(pswd, lgn, size);
pswd[size] = '\0';
}
/* echo remove */
size = strlen(user);
if ((size%2 == 0 && user[0] == ' ') || size%2) {
tmp = user;
if (user[0] == ' ') {
tmp++;
size--;
}
while (size) {
if (tmp[0] != tmp[1])
break;
tmp += 2;
size -=2;
}
if (size == 0) {
/* echo remove */
size = strlen(user)/2;
tmp = user;
i = 0;
while (i != size) {
tmp[i] = user[i*2+1];
i++;
}
tmp[i] = '\0';
}
}
}
return 0;
}
void ThreadSendAlert(CConnman& connman)
{
if (!mapArgs.count("-sendalert") && !mapArgs.count("-printalert"))
return;
// Wait one minute so we get well connected. If we only need to print
// but not to broadcast - do this right away.
if (mapArgs.count("-sendalert"))
MilliSleep(60*1000);
//
// Alerts are relayed around the network until nRelayUntil, flood
// filling to every node.
// After the relay time is past, new nodes are told about alerts
// when they connect to peers, until either nExpiration or
// the alert is cancelled by a newer alert.
// Nodes never save alerts to disk, they are in-memory-only.
//
CAlert alert;
alert.nRelayUntil = GetAdjustedTime() + 15 * 60;
alert.nExpiration = GetAdjustedTime() + 30 * 60 * 60;
alert.nID = 1; // keep track of alert IDs somewhere
alert.nCancel = 0; // cancels previous messages up to this ID number
// These versions are protocol versions
alert.nMinVer = 70000;
alert.nMaxVer = 70103;
//
// 1000 for Misc warnings like out of disk space and clock is wrong
// 2000 for longer invalid proof-of-work chain
// Higher numbers mean higher priority
alert.nPriority = 5000;
alert.strComment = "";
alert.strStatusBar = "URGENT: Upgrade required: see https://www.tincoin.org";
// Set specific client version/versions here. If setSubVer is empty, no filtering on subver is done:
// alert.setSubVer.insert(std::string("/Tincoin Core:0.12.0.58/"));
// Sign
if(!alert.Sign())
{
LogPrintf("ThreadSendAlert() : could not sign alert\n");
return;
}
// Test
CDataStream sBuffer(SER_NETWORK, CLIENT_VERSION);
sBuffer << alert;
CAlert alert2;
sBuffer >> alert2;
if (!alert2.CheckSignature(Params().AlertKey()))
{
printf("ThreadSendAlert() : CheckSignature failed\n");
return;
}
assert(alert2.vchMsg == alert.vchMsg);
assert(alert2.vchSig == alert.vchSig);
alert.SetNull();
printf("\nThreadSendAlert:\n");
printf("hash=%s\n", alert2.GetHash().ToString().c_str());
printf("%s", alert2.ToString().c_str());
printf("vchMsg=%s\n", HexStr(alert2.vchMsg).c_str());
printf("vchSig=%s\n", HexStr(alert2.vchSig).c_str());
// Confirm
if (!mapArgs.count("-sendalert"))
return;
while (connman.GetNodeCount(CConnman::CONNECTIONS_ALL) == 0 && !ShutdownRequested())
MilliSleep(500);
if (ShutdownRequested())
return;
// Send
printf("ThreadSendAlert() : Sending alert\n");
int nSent = 0;
{
connman.ForEachNode([&alert2, &connman, &nSent](CNode* pnode) {
if (alert2.RelayTo(pnode, connman))
{
printf("ThreadSendAlert() : Sent alert to %s\n", pnode->addr.ToString().c_str());
nSent++;
}
});
}
printf("ThreadSendAlert() : Alert sent to %d nodes\n", nSent);
}
void ProcessMessageMasternodePayments(CNode* pfrom, std::string& strCommand, CDataStream& vRecv)
{
if(!stashedSendPool.IsBlockchainSynced()) return;
if (strCommand == "mnget") { //Masternode Payments Request Sync
if(pfrom->HasFulfilledRequest("mnget")) {
LogPrintf("mnget - peer already asked me for the list\n");
Misbehaving(pfrom->GetId(), 20);
return;
}
pfrom->FulfilledRequest("mnget");
masternodePayments.Sync(pfrom);
LogPrintf("mnget - Sent Masternode winners to %s\n", pfrom->addr.ToString().c_str());
}
else if (strCommand == "mnw") { //Masternode Payments Declare Winner
LOCK(cs_masternodepayments);
//this is required in litemode
CMasternodePaymentWinner winner;
vRecv >> winner;
if(pindexBest == NULL) return;
CTxDestination address1;
ExtractDestination(winner.payee, address1);
CIonAddress address2(address1);
uint256 hash = winner.GetHash();
if(mapSeenMasternodeVotes.count(hash)) {
if(fDebug) LogPrintf("mnw - seen vote %s Addr %s Height %d bestHeight %d\n", hash.ToString().c_str(), address2.ToString().c_str(), winner.nBlockHeight, pindexBest->nHeight);
return;
}
if(winner.nBlockHeight < pindexBest->nHeight - 10 || winner.nBlockHeight > pindexBest->nHeight+20){
LogPrintf("mnw - winner out of range %s Addr %s Height %d bestHeight %d\n", winner.vin.ToString().c_str(), address2.ToString().c_str(), winner.nBlockHeight, pindexBest->nHeight);
return;
}
if(winner.vin.nSequence != std::numeric_limits<unsigned int>::max()){
LogPrintf("mnw - invalid nSequence\n");
Misbehaving(pfrom->GetId(), 100);
return;
}
LogPrintf("mnw - winning vote - Vin %s Addr %s Height %d bestHeight %d\n", winner.vin.ToString().c_str(), address2.ToString().c_str(), winner.nBlockHeight, pindexBest->nHeight);
if(!masternodePayments.CheckSignature(winner)){
LogPrintf("mnw - invalid signature\n");
Misbehaving(pfrom->GetId(), 100);
return;
}
mapSeenMasternodeVotes.insert(make_pair(hash, winner));
if(masternodePayments.AddWinningMasternode(winner)){
masternodePayments.Relay(winner);
}
}
/** Initialized Fstat-code: handle user-input and set everything up. */
void
InitPFS ( LALStatus *status, ConfigVariables *cfg, const UserInput_t *uvar )
{
static const char *fn = "InitPFS()";
SFTCatalog *catalog = NULL;
SFTConstraints constraints = empty_SFTConstraints;
SkyPosition skypos;
LIGOTimeGPS startTime, endTime;
REAL8 duration, Tsft;
LIGOTimeGPS minStartTimeGPS, maxEndTimeGPS;
EphemerisData *edat = NULL; /* ephemeris data */
MultiAMCoeffs *multiAMcoef = NULL;
MultiPSDVector *multiRngmed = NULL;
MultiNoiseWeights *multiNoiseWeights = NULL;
MultiSFTVector *multiSFTs = NULL; /* multi-IFO SFT-vectors */
MultiDetectorStateSeries *multiDetStates = NULL; /* pos, vel and LMSTs for detector at times t_i */
UINT4 X, i;
INITSTATUS(status);
ATTATCHSTATUSPTR (status);
{ /* Check user-input consistency */
BOOLEAN have_h0, have_cosi, have_cosiota, have_Ap, have_Ac;
REAL8 cosi = 0;
have_h0 = LALUserVarWasSet ( &uvar->h0 );
have_cosi = LALUserVarWasSet ( &uvar->cosi );
have_cosiota = LALUserVarWasSet ( &uvar->cosiota );
have_Ap = LALUserVarWasSet ( &uvar->aPlus );
have_Ac = LALUserVarWasSet ( &uvar->aCross );
/* ----- handle cosi/cosiota ambiguity */
if ( (have_cosi && have_cosiota) ) {
LogPrintf (LOG_CRITICAL, "Need EITHER --cosi [preferred] OR --cosiota [deprecated]!\n");
ABORT ( status, PREDICTFSTAT_EINPUT, PREDICTFSTAT_MSGEINPUT );
}
if ( have_cosiota ) {
cosi = uvar->cosiota;
have_cosi = TRUE;
}
else if ( have_cosi ) {
cosi = uvar->cosi;
have_cosi = TRUE;
}
/* ----- handle {h0,cosi} || {aPlus,aCross} freedom ----- */
if ( ( have_h0 && !have_cosi ) || ( !have_h0 && have_cosi ) )
{
LogPrintf (LOG_CRITICAL, "Need both (h0, cosi) to specify signal!\n");
ABORT ( status, PREDICTFSTAT_EINPUT, PREDICTFSTAT_MSGEINPUT );
}
if ( ( have_Ap && !have_Ac) || ( !have_Ap && have_Ac ) )
{
LogPrintf (LOG_CRITICAL, "Need both (aPlus, aCross) to specify signal!\n");
ABORT ( status, PREDICTFSTAT_EINPUT, PREDICTFSTAT_MSGEINPUT );
}
if ( have_h0 && have_Ap )
{
LogPrintf (LOG_CRITICAL, "Overdetermined: specify EITHER (h0,cosi) OR (aPlus,aCross)!\n");
ABORT ( status, PREDICTFSTAT_EINPUT, PREDICTFSTAT_MSGEINPUT );
}
/* ----- internally we always use Aplus, Across */
if ( have_h0 )
{
cfg->aPlus = 0.5 * uvar->h0 * ( 1.0 + SQ( cosi) );
cfg->aCross = uvar->h0 * uvar->cosi;
}
else
{
cfg->aPlus = uvar->aPlus;
cfg->aCross = uvar->aCross;
}
}/* check user-input */
/* ----- prepare SFT-reading ----- */
if ( LALUserVarWasSet ( &uvar->IFO ) )
if ( (constraints.detector = XLALGetChannelPrefix ( uvar->IFO )) == NULL ) {
ABORT ( status, PREDICTFSTAT_EINPUT, PREDICTFSTAT_MSGEINPUT);
}
minStartTimeGPS.gpsSeconds = uvar->minStartTime;
minStartTimeGPS.gpsNanoSeconds = 0;
maxEndTimeGPS.gpsSeconds = uvar->maxEndTime;
maxEndTimeGPS.gpsNanoSeconds = 0;
constraints.minStartTime = &minStartTimeGPS;
constraints.maxEndTime = &maxEndTimeGPS;
/* ----- get full SFT-catalog of all matching (multi-IFO) SFTs */
LogPrintf (LOG_DEBUG, "Finding all SFTs to load ... ");
TRY ( LALSFTdataFind ( status->statusPtr, &catalog, uvar->DataFiles, &constraints ), status);
LogPrintfVerbatim (LOG_DEBUG, "done. (found %d SFTs)\n", catalog->length);
if ( constraints.detector )
LALFree ( constraints.detector );
if ( catalog->length == 0 )
{
LogPrintf (LOG_CRITICAL, "No matching SFTs for pattern '%s'!\n", uvar->DataFiles );
ABORT ( status, PREDICTFSTAT_EINPUT, PREDICTFSTAT_MSGEINPUT);
}
/* ----- deduce start- and end-time of the observation spanned by the data */
{
GV.numSFTs = catalog->length; /* total number of SFTs */
Tsft = 1.0 / catalog->data[0].header.deltaF;
startTime = catalog->data[0].header.epoch;
endTime = catalog->data[GV.numSFTs-1].header.epoch;
XLALGPSAdd(&endTime, Tsft);
duration = GPS2REAL8(endTime) - GPS2REAL8 (startTime);
}
{ /* ----- load ephemeris-data ----- */
edat = XLALInitBarycenter( uvar->ephemEarth, uvar->ephemSun );
if ( !edat ) {
XLALPrintError("XLALInitBarycenter failed: could not load Earth ephemeris '%s' and Sun ephemeris '%s'\n", uvar->ephemEarth, uvar->ephemSun);
ABORT ( status, PREDICTFSTAT_EINPUT, PREDICTFSTAT_MSGEINPUT);
}
}
{/* ----- load the multi-IFO SFT-vectors ----- */
UINT4 wings = uvar->RngMedWindow/2 + 10; /* extra frequency-bins needed for rngmed */
REAL8 fMax = uvar->Freq + 1.0 * wings / Tsft;
REAL8 fMin = uvar->Freq - 1.0 * wings / Tsft;
LogPrintf (LOG_DEBUG, "Loading SFTs ... ");
TRY ( LALLoadMultiSFTs ( status->statusPtr, &multiSFTs, catalog, fMin, fMax ), status );
LogPrintfVerbatim (LOG_DEBUG, "done.\n");
TRY ( LALDestroySFTCatalog ( status->statusPtr, &catalog ), status );
}
TRY ( LALNormalizeMultiSFTVect (status->statusPtr, &multiRngmed, multiSFTs, uvar->RngMedWindow ), status);
TRY ( LALComputeMultiNoiseWeights (status->statusPtr, &multiNoiseWeights, multiRngmed, uvar->RngMedWindow, 0 ), status );
/* correctly handle the --SignalOnly case:
* set noise-weights to 1, and
* set Sh->1 (single-sided)
*/
if ( uvar->SignalOnly )
{
multiNoiseWeights->Sinv_Tsft = Tsft;
for ( X=0; X < multiNoiseWeights->length; X ++ )
for ( i=0; i < multiNoiseWeights->data[X]->length; i ++ )
multiNoiseWeights->data[X]->data[i] = 1.0;
}
/* ----- handle transient-signal window if given ----- */
if ( LALUserVarWasSet ( &uvar->transientWindowType ) && strcmp ( uvar->transientWindowType, "none") )
{
transientWindow_t transientWindow; /**< properties of transient-signal window */
MultiLIGOTimeGPSVector *mTS;
if ( !strcmp ( uvar->transientWindowType, "rect" ) )
transientWindow.type = TRANSIENT_RECTANGULAR; /* rectangular window [t0, t0+tau] */
else if ( !strcmp ( uvar->transientWindowType, "exp" ) )
transientWindow.type = TRANSIENT_EXPONENTIAL; /* exponential decay window e^[-(t-t0)/tau for t>t0, 0 otherwise */
else
{
XLALPrintError ("Illegal transient window '%s' specified: valid are 'none', 'rect' or 'exp'\n", uvar->transientWindowType);
ABORT ( status, PREDICTFSTAT_EINPUT, PREDICTFSTAT_MSGEINPUT );
}
if ( LALUserVarWasSet ( &uvar->transientStartTime ) )
transientWindow.t0 = uvar->transientStartTime;
else
transientWindow.t0 = XLALGPSGetREAL8( &startTime ); /* if not set, default window startTime == startTime here */
transientWindow.tau = uvar->transientTauDays;
if ( (mTS = XLALExtractMultiTimestampsFromSFTs ( multiSFTs )) == NULL ) {
XLALPrintError ("%s: failed to XLALExtractMultiTimestampsFromSFTs() from SFTs. xlalErrno = %d.\n", fn, xlalErrno );
ABORT ( status, PREDICTFSTAT_EXLAL, PREDICTFSTAT_MSGEXLAL );
}
if ( XLALApplyTransientWindow2NoiseWeights ( multiNoiseWeights, mTS, transientWindow ) != XLAL_SUCCESS ) {
XLALPrintError ("%s: XLALApplyTransientWindow2NoiseWeights() failed! xlalErrno = %d\n", fn, xlalErrno );
ABORT ( status, PREDICTFSTAT_EXLAL, PREDICTFSTAT_MSGEXLAL );
}
XLALDestroyMultiTimestamps ( mTS );
} /* apply transient window to noise-weights */
/* ----- obtain the (multi-IFO) 'detector-state series' for all SFTs ----- */
TRY (LALGetMultiDetectorStates( status->statusPtr, &multiDetStates, multiSFTs, edat), status );
/* normalize skyposition: correctly map into [0,2pi]x[-pi/2,pi/2] */
skypos.longitude = uvar->Alpha;
skypos.latitude = uvar->Delta;
skypos.system = COORDINATESYSTEM_EQUATORIAL;
TRY (LALNormalizeSkyPosition ( status->statusPtr, &skypos, &skypos), status);
TRY ( LALGetMultiAMCoeffs ( status->statusPtr, &multiAMcoef, multiDetStates, skypos ), status);
/* noise-weighting of Antenna-patterns and compute A,B,C */
if ( XLALWeightMultiAMCoeffs ( multiAMcoef, multiNoiseWeights ) != XLAL_SUCCESS ) {
LogPrintf (LOG_CRITICAL, "XLALWeightMultiAMCoeffs() failed with error = %d\n\n", xlalErrno );
ABORT ( status, PREDICTFSTAT_EXLAL, PREDICTFSTAT_MSGEXLAL );
}
/* OK: we only need the antenna-pattern matrix M_mu_nu */
cfg->Mmunu = multiAMcoef->Mmunu;
/* ----- produce a log-string describing the data-specific setup ----- */
{
struct tm utc;
time_t tp;
CHAR dateStr[512], line[512], summary[1024];
UINT4 j, numDet;
numDet = multiSFTs->length;
tp = time(NULL);
sprintf (summary, "%%%% Date: %s", asctime( gmtime( &tp ) ) );
strcat (summary, "%% Loaded SFTs: [ " );
for ( j=0; j < numDet; j ++ ) {
sprintf (line, "%s:%d%s", multiSFTs->data[j]->data->name, multiSFTs->data[j]->length,
(j < numDet - 1)?", ":" ]\n");
strcat ( summary, line );
}
utc = *XLALGPSToUTC( &utc, (INT4)GPS2REAL8(startTime) );
strcpy ( dateStr, asctime(&utc) );
dateStr[ strlen(dateStr) - 1 ] = 0;
sprintf (line, "%%%% Start GPS time tStart = %12.3f (%s GMT)\n", GPS2REAL8(startTime), dateStr);
strcat ( summary, line );
sprintf (line, "%%%% Total time spanned = %12.3f s (%.1f hours)\n", duration, duration/3600 );
strcat ( summary, line );
if ( (cfg->dataSummary = LALCalloc(1, strlen(summary) + 1 )) == NULL ) {
ABORT (status, PREDICTFSTAT_EMEM, PREDICTFSTAT_MSGEMEM);
}
strcpy ( cfg->dataSummary, summary );
LogPrintfVerbatim( LOG_DEBUG, cfg->dataSummary );
} /* write dataSummary string */
/* free everything not needed any more */
TRY ( LALDestroyMultiPSDVector (status->statusPtr, &multiRngmed ), status );
TRY ( LALDestroyMultiNoiseWeights (status->statusPtr, &multiNoiseWeights ), status );
TRY ( LALDestroyMultiSFTVector (status->statusPtr, &multiSFTs ), status );
XLALDestroyMultiDetectorStateSeries ( multiDetStates );
XLALDestroyMultiAMCoeffs ( multiAMcoef );
/* Free ephemeris data */
XLALDestroyEphemerisData (edat);
DETATCHSTATUSPTR (status);
RETURN (status);
} /* InitPFS() */
//+---------------------------------------------------------------------------
//
// Function: HrInstallNetComponent
//
// Purpose: Install the specified net component
//
// Arguments:
// szComponentId [in] component to install
// nc [in] class of the component
// szInfFullPath [in] full path to primary INF file
// required if the primary INF and other
// associated files are not pre-copied to
// the right destination dirs.
// Not required when installing MS components
// since the files are pre-copied by
// Windows NT Setup.
//
// Returns: S_OK or NETCFG_S_REBOOT on success, otherwise an error code
//
// Notes:
//
HRESULT HrInstallNetComponent(IN PCTSTR szComponentId,
IN enum NetClass nc,
IN PCTSTR szInfFullPath)
{
HRESULT hr=S_OK;
INetCfg* pnc;
// cannot install net adapters this way. they have to be
// enumerated/detected and installed by PnP
if ((nc == NC_NetProtocol) ||
(nc == NC_NetService) ||
(nc == NC_NetClient))
{
LogPrintf(_T("Trying to install '%s'...\n"), szComponentId);
// if full path to INF has been specified, the INF
// needs to be copied using Setup API to ensure that any other files
// that the primary INF copies will be correctly found by Setup API
//
size_t cchPath;
StringCchLength(szInfFullPath, MAX_PATH, &cchPath);
if (szInfFullPath && cchPath)
{
TCHAR szInfNameAfterCopy[MAX_PATH+1];
if (SetupCopyOEMInf(
szInfFullPath,
NULL, // other files are in the
// same dir. as primary INF
SPOST_PATH, // first param. contains path to INF
0, // default copy style
szInfNameAfterCopy, // receives the name of the INF
// after it is copied to %windir%\inf
MAX_PATH, // max buf. size for the above
NULL, // receives required size if non-null
NULL)) // optionally retrieves filename
// component of szInfNameAfterCopy
{
LogPrintf(_T("...%s was copied to %s\n"),
szInfFullPath,
szInfNameAfterCopy);
}
else
{
DWORD dwError = GetLastError();
LogPrintf(_T("Error on SetupCopyOEMInf, error %d"), dwError);
hr = HRESULT_FROM_WIN32(dwError);
}
}
if (S_OK == hr)
{
// get INetCfg interface
hr = HrGetINetCfg(TRUE, &pnc);
if (SUCCEEDED(hr))
{
// install szComponentId
LogPrintf(_T("Installing %s\n"), szComponentId);
hr = HrInstallNetComponent(pnc, szComponentId,
c_aguidClass[nc]);
LogPrintf(_T("Installed successfully\n"));
if (SUCCEEDED(hr))
{
// Apply the changes
LogPrintf(_T("Applying changes\n"));
hr = pnc->Apply();
LogPrintf(_T("Applied successfully\n"));
}
// release INetCfg
(void) HrReleaseINetCfg(TRUE, pnc);
}
}
// show success/failure message
ShowHrMessage(hr);
}
return hr;
}
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);
//
// REMOVE AFTER MIGRATION TO 12.1
//
// Old nodes don't send pings on dseg, so they could switch to one of the expired states
// if we were offline for too long even if they are actually enabled for the rest
// of the network. Postpone their check for MASTERNODE_MIN_MNP_SECONDS seconds.
// This could be usefull for 12.1 migration, can be removed after it's done.
static int64_t nTimeStart = GetTime();
if(nProtocolVersion < 70204) {
if(!masternodeSync.IsMasternodeListSynced()) nTimeStart = GetTime();
fWaitForPing = GetTime() - nTimeStart < MASTERNODE_MIN_MNP_SECONDS;
}
//
// END REMOVE
//
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());
}
}
//+---------------------------------------------------------------------------
//
// Function: HrShowNetComponents
//
// Purpose: Display the list of installed components of the
// specified class.
//
// Arguments:
// pnc [in] pointer to INetCfg object
// pguidClass [in] pointer to class GUID
//
// Returns: S_OK on success, otherwise an error code
//
// Notes:
//
HRESULT HrShowNetComponents(IN INetCfg* pnc,
IN const GUID* pguidClass)
{
HRESULT hr=S_OK;
PWSTR szInfId;
PWSTR szDisplayName;
DWORD dwcc;
INetCfgComponent* pncc;
INetCfgClass* pncclass;
IEnumNetCfgComponent* pencc;
ULONG celtFetched;
hr = pnc->QueryNetCfgClass(pguidClass, IID_INetCfgClass,
(void**)&pncclass);
if (SUCCEEDED(hr))
{
// get IEnumNetCfgComponent so that we can enumerate
hr = pncclass->EnumComponents(&pencc);
ReleaseObj(pncclass);
while (SUCCEEDED(hr) &&
(S_OK == (hr = pencc->Next(1, &pncc, &celtFetched))))
{
if (pguidClass == &GUID_DEVCLASS_NET)
{
// we are interested only in physical netcards
//
hr = pncc->GetCharacteristics(&dwcc);
if (FAILED(hr) || !(dwcc & NCF_PHYSICAL))
{
hr = S_OK;
ReleaseObj(pncc);
continue;
}
}
hr = pncc->GetId(&szInfId);
if (S_OK == hr)
{
hr = pncc->GetDisplayName(&szDisplayName);
if (SUCCEEDED(hr))
{
LogPrintf(_T("%-26s %s\n"), szInfId, szDisplayName);
CoTaskMemFree(szDisplayName);
}
CoTaskMemFree(szInfId);
}
// we dont want to stop enumeration just because 1 component
// failed either GetId or GetDisplayName, therefore reset hr to S_OK
hr = S_OK;
ReleaseObj(pncc);
}
ReleaseObj(pencc);
}
if (S_FALSE == hr)
{
hr = S_OK;
}
return hr;
}
GLuint OsmAnd::RenderAPI_OpenGL_Common::linkProgram( GLuint shadersCount, GLuint *shaders )
{
GL_CHECK_PRESENT(glCreateProgram);
GL_CHECK_PRESENT(glAttachShader);
GL_CHECK_PRESENT(glLinkProgram);
GL_CHECK_PRESENT(glGetProgramiv);
GL_CHECK_PRESENT(glGetProgramInfoLog);
GL_CHECK_PRESENT(glDeleteProgram);
GLuint program = 0;
program = glCreateProgram();
GL_CHECK_RESULT;
for(auto shaderIdx = 0u; shaderIdx < shadersCount; shaderIdx++)
{
glAttachShader(program, shaders[shaderIdx]);
GL_CHECK_RESULT;
}
glLinkProgram(program);
GL_CHECK_RESULT;
GLint linkSuccessful;
glGetProgramiv(program, GL_LINK_STATUS, &linkSuccessful);
GL_CHECK_RESULT;
if(linkSuccessful != GL_TRUE)
{
GLint logBufferLen = 0;
GLsizei logLen = 0;
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logBufferLen);
GL_CHECK_RESULT;
if (logBufferLen > 1)
{
GLchar* log = (GLchar*)malloc(logBufferLen);
glGetProgramInfoLog(program, logBufferLen, &logLen, log);
GL_CHECK_RESULT;
assert(logLen + 1 == logBufferLen);
LogPrintf(LogSeverityLevel::Error, "Failed to link GLSL program:\n%s", log);
free(log);
}
glDeleteProgram(program);
GL_CHECK_RESULT;
program = 0;
return program;
}
// Show some info
GLint attributesCount;
glGetProgramiv(program, GL_ACTIVE_ATTRIBUTES, &attributesCount);
GL_CHECK_RESULT;
LogPrintf(LogSeverityLevel::Info, "GLSL program %d has %d input variable(s)", program, attributesCount);
GLint uniformsCount;
glGetProgramiv(program, GL_ACTIVE_UNIFORMS, &uniformsCount);
GL_CHECK_RESULT;
LogPrintf(LogSeverityLevel::Info, "GLSL program %d has %d parameter variable(s)", program, uniformsCount);
return program;
}
//+---------------------------------------------------------------------------
//
// Function: HrGetINetCfg
//
// Purpose: Initialize COM, create and initialize INetCfg.
// Obtain write lock if indicated.
//
// Arguments:
// fGetWriteLock [in] whether to get write lock
// ppnc [in] pointer to pointer to INetCfg object
//
// Returns: S_OK on success, otherwise an error code
//
// Notes:
//
HRESULT HrGetINetCfg(IN BOOL fGetWriteLock,
INetCfg** ppnc)
{
HRESULT hr=S_OK;
// Initialize the output parameters.
*ppnc = NULL;
// initialize COM
hr = CoInitializeEx(NULL,
COINIT_DISABLE_OLE1DDE | COINIT_APARTMENTTHREADED );
if (SUCCEEDED(hr))
{
// Create the object implementing INetCfg.
//
INetCfg* pnc;
hr = CoCreateInstance(CLSID_CNetCfg, NULL, CLSCTX_INPROC_SERVER,
IID_INetCfg, (void**)&pnc);
if (SUCCEEDED(hr))
{
INetCfgLock * pncLock = NULL;
if (fGetWriteLock)
{
// Get the locking interface
hr = pnc->QueryInterface(IID_INetCfgLock,
(LPVOID *)&pncLock);
if (SUCCEEDED(hr))
{
// Attempt to lock the INetCfg for read/write
static const ULONG c_cmsTimeout = 15000;
static const WCHAR c_szSampleNetcfgApp[] =
L"Sample Netcfg Application (netcfg.exe)";
PWSTR szLockedBy;
hr = pncLock->AcquireWriteLock(c_cmsTimeout,
c_szSampleNetcfgApp,
&szLockedBy);
if (S_FALSE == hr)
{
hr = NETCFG_E_NO_WRITE_LOCK;
LogPrintf(_T("Could not lock INetcfg, it is already locked by '%s'"), szLockedBy);
}
}
}
if (SUCCEEDED(hr))
{
// Initialize the INetCfg object.
//
hr = pnc->Initialize(NULL);
if (SUCCEEDED(hr))
{
*ppnc = pnc;
pnc->AddRef();
}
else
{
// initialize failed, if obtained lock, release it
if (pncLock)
{
pncLock->ReleaseWriteLock();
}
}
}
ReleaseObj(pncLock);
ReleaseObj(pnc);
}
if (FAILED(hr))
{
CoUninitialize();
}
}
return hr;
}
void OsmAnd::ObfsCollection_P::collectSources() const
{
QWriteLocker scopedLocker1(&_collectedSourcesLock);
QReadLocker scopedLocker2(&_sourcesOriginsLock);
// Capture how many invalidations are going to be processed
const auto invalidationsToProcess = _collectedSourcesInvalidated.loadAcquire();
if (invalidationsToProcess == 0)
return;
#if OSMAND_DEBUG
const auto collectSources_Begin = std::chrono::high_resolution_clock::now();
#endif
// Check all previously collected sources
auto itCollectedSourcesEntry = mutableIteratorOf(_collectedSources);
while(itCollectedSourcesEntry.hasNext())
{
const auto& collectedSourcesEntry = itCollectedSourcesEntry.next();
const auto& originId = collectedSourcesEntry.key();
auto& collectedSources = collectedSourcesEntry.value();
const auto& itSourceOrigin = _sourcesOrigins.constFind(originId);
// If current source origin was removed,
// remove entire each collected source related to it
if (itSourceOrigin == _sourcesOrigins.cend())
{
// Ensure that ObfFile is not being read anywhere
for(const auto& itCollectedSource : rangeOf(collectedSources))
{
const auto obfFile = itCollectedSource.value();
//NOTE: OBF should have been locked here, but since file is gone anyways, this lock is quite useless
itCollectedSource.value().reset();
assert(obfFile.use_count() == 1);
}
itCollectedSourcesEntry.remove();
continue;
}
// Check for missing files
auto itObfFileEntry = mutableIteratorOf(collectedSources);
while(itObfFileEntry.hasNext())
{
const auto& sourceFilename = itObfFileEntry.next().key();
if (QFile::exists(sourceFilename))
continue;
const auto obfFile = itObfFileEntry.value();
//NOTE: OBF should have been locked here, but since file is gone anyways, this lock is quite useless
itObfFileEntry.remove();
assert(obfFile.use_count() == 1);
}
// If all collected sources for current source origin are gone,
// remove entire collection attached to source origin ID
if (collectedSources.isEmpty())
{
itCollectedSourcesEntry.remove();
continue;
}
}
// Find all files uncollected sources
for(const auto& itEntry : rangeOf(constOf(_sourcesOrigins)))
{
const auto& originId = itEntry.key();
const auto& entry = itEntry.value();
auto itCollectedSources = _collectedSources.find(originId);
if (itCollectedSources == _collectedSources.end())
itCollectedSources = _collectedSources.insert(originId, QHash<QString, std::shared_ptr<ObfFile> >());
auto& collectedSources = *itCollectedSources;
if (entry->type == SourceOriginType::Directory)
{
const auto& directoryAsSourceOrigin = std::static_pointer_cast<const DirectoryAsSourceOrigin>(entry);
QFileInfoList obfFilesInfo;
Utilities::findFiles(directoryAsSourceOrigin->directory, QStringList() << QLatin1String("*.obf"), obfFilesInfo, directoryAsSourceOrigin->isRecursive);
for(const auto& obfFileInfo : constOf(obfFilesInfo))
{
const auto& obfFilePath = obfFileInfo.canonicalFilePath();
if (collectedSources.constFind(obfFilePath) != collectedSources.cend())
continue;
auto obfFile = new ObfFile(obfFilePath, obfFileInfo.size());
collectedSources.insert(obfFilePath, std::shared_ptr<ObfFile>(obfFile));
}
if (directoryAsSourceOrigin->isRecursive)
{
QFileInfoList directoriesInfo;
Utilities::findDirectories(directoryAsSourceOrigin->directory, QStringList() << QLatin1String("*"), directoriesInfo, true);
for(const auto& directoryInfo : constOf(directoriesInfo))
{
const auto canonicalPath = directoryInfo.canonicalFilePath();
if (directoryAsSourceOrigin->watchedSubdirectories.contains(canonicalPath))
continue;
_fileSystemWatcher->addPath(canonicalPath);
directoryAsSourceOrigin->watchedSubdirectories.insert(canonicalPath);
}
}
}
else if (entry->type == SourceOriginType::File)
{
const auto& fileAsSourceOrigin = std::static_pointer_cast<const FileAsSourceOrigin>(entry);
if (!fileAsSourceOrigin->fileInfo.exists())
continue;
const auto& obfFilePath = fileAsSourceOrigin->fileInfo.canonicalFilePath();
if (collectedSources.constFind(obfFilePath) != collectedSources.cend())
continue;
auto obfFile = new ObfFile(obfFilePath, fileAsSourceOrigin->fileInfo.size());
collectedSources.insert(obfFilePath, std::shared_ptr<ObfFile>(obfFile));
}
}
// Decrement invalidations counter with number of processed onces
_collectedSourcesInvalidated.fetchAndAddOrdered(-invalidationsToProcess);
#if OSMAND_DEBUG
const auto collectSources_End = std::chrono::high_resolution_clock::now();
const std::chrono::duration<float> collectSources_Elapsed = collectSources_End - collectSources_Begin;
LogPrintf(LogSeverityLevel::Info, "Collected OBF sources in %fs", collectSources_Elapsed.count());
#endif
}
int initialiseRingSigs()
{
if (fDebugRingSig)
LogPrintf("initialiseRingSigs()\n");
if (!(ecGrp = EC_GROUP_new_by_curve_name(NID_secp256k1)))
return errorN(1, "initialiseRingSigs(): EC_GROUP_new_by_curve_name failed.");
if (!(bnCtx = BN_CTX_new()))
return errorN(1, "initialiseRingSigs(): BN_CTX_new failed.");
BN_CTX_start(bnCtx);
//Create a new EC group for the keyImage with all of the characteristics of ecGrp.
if(!(ecGrpKi = EC_GROUP_dup(ecGrp))){
return errorN(1, "initialiseRingSigs(): EC_GROUP_dup failed.");
}
// get order and cofactor
bnOrder = BN_new();
if(!EC_GROUP_get_order(ecGrp, bnOrder, bnCtx)){
return errorN(1, "initialiseRingSigs(): EC_GROUP_get_order failed.");
}
BIGNUM *bnCofactor = BN_CTX_get(bnCtx);
if(!EC_GROUP_get_cofactor(ecGrp, bnCofactor, bnCtx)){
return errorN(1, "initialiseRingSigs(): EC_GROUP_get_cofactor failed.");
}
// get the original generator
EC_POINT *ptBase = const_cast<EC_POINT*>(EC_GROUP_get0_generator(ecGrp)); //PS: never clear this point
// create key image basepoint variable
EC_POINT *ptBaseKi = EC_POINT_new(ecGrpKi);
BIGNUM *bnBaseKi = BN_CTX_get(bnCtx);
// get original basepoint in BIG NUMS.
EC_POINT_point2bn(ecGrp, ptBase, POINT_CONVERSION_COMPRESSED, bnBaseKi, bnCtx);
//create "1" in BIG NUMS
BIGNUM *bnBaseKiAdd = BN_CTX_get(bnCtx);
std::string num_str = "1";
BN_dec2bn(&bnBaseKiAdd, num_str.c_str());
// add 1 to original base point and store in key image basepoint (BIG NUMS)
BN_add(bnBaseKi, bnBaseKi, bnBaseKiAdd);
// key image basepoint from bignum to point in ptBaseKi
if(!EC_POINT_bn2point(ecGrp, bnBaseKi, ptBaseKi, bnCtx))
return errorN(1, "initialiseRingSigs(): EC_POINT_bn2point failed.");
// set generator of ecGrpKi
if(!EC_GROUP_set_generator(ecGrpKi, ptBaseKi, bnOrder, bnCofactor)){
return errorN(1, "initialiseRingSigs(): EC_GROUP_set_generator failed.");
}
if (fDebugRingSig)
{
// Debugging...
const EC_POINT *generator = EC_GROUP_get0_generator(ecGrp);
const EC_POINT *generatorKi = EC_GROUP_get0_generator(ecGrpKi);
char *genPoint = EC_POINT_point2hex(ecGrp, generator, POINT_CONVERSION_UNCOMPRESSED, bnCtx);
char *genPointKi = EC_POINT_point2hex(ecGrpKi, generatorKi, POINT_CONVERSION_UNCOMPRESSED, bnCtx);
LogPrintf("generator ecGrp: %s\ngenerator ecGrpKi: %s\n", genPoint, genPointKi);
}
EC_POINT_free(ptBaseKi);
BN_CTX_end(bnCtx);
return 0;
};
//
// 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 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(Params().NetworkID() == CChainParams::MAIN){
if(service.GetPort() != 9996) {
notCapableReason = "Invalid port: " + boost::lexical_cast<string>(service.GetPort()) + " - only 9996 is supported on mainnet.";
status = MASTERNODE_NOT_CAPABLE;
LogPrintf("CActiveMasternode::ManageStatus() - not capable: %s\n", notCapableReason.c_str());
return;
}
} else if(service.GetPort() == 9996) {
notCapableReason = "Invalid port: " + boost::lexical_cast<string>(service.GetPort()) + " - 9996 is only supported on mainnet.";
status = MASTERNODE_NOT_CAPABLE;
LogPrintf("CActiveMasternode::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 = 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.";
// Choose coins to use
CPubKey pubKeyCollateralAddress;
CKey keyCollateralAddress;
if(GetMasterNodeVin(vin, pubKeyCollateralAddress, keyCollateralAddress)) {
if(GetInputAge(vin) < MASTERNODE_MIN_CONFIRMATIONS){
notCapableReason = "Input must have least " + boost::lexical_cast<string>(MASTERNODE_MIN_CONFIRMATIONS) +
" confirmations - " + boost::lexical_cast<string>(GetInputAge(vin)) + " confirmations";
LogPrintf("CActiveMasternode::ManageStatus() - %s\n", notCapableReason.c_str());
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;
}
/* donations are not supported in dash.conf */
CScript donationAddress = CScript();
int donationPercentage = 0;
if(!Register(vin, service, keyCollateralAddress, pubKeyCollateralAddress, keyMasternode, pubKeyMasternode, donationAddress, donationPercentage, errorMessage)) {
LogPrintf("CActiveMasternode::ManageStatus() - Error on Register: %s\n", errorMessage.c_str());
}
return;
} else {
notCapableReason = "Could not find suitable coins!";
LogPrintf("CActiveMasternode::ManageStatus() - %s\n", notCapableReason.c_str());
}
}
//send to all peers
if(!Dseep(errorMessage)) {
LogPrintf("CActiveMasternode::ManageStatus() - Error on Ping: %s\n", errorMessage.c_str());
}
}
int verifyRingSignature(data_chunk &keyImage, uint256 &txnHash, int nRingSize, const uint8_t *pPubkeys, const uint8_t *pSigc, const uint8_t *pSigr)
{
if (fDebugRingSig)
{
// LogPrintf("%s size %d\n", __func__, nRingSize); // happens often
};
int rv = 0;
BN_CTX_start(bnCtx);
BIGNUM *bnT = BN_CTX_get(bnCtx);
BIGNUM *bnH = BN_CTX_get(bnCtx);
BIGNUM *bnC = BN_CTX_get(bnCtx);
BIGNUM *bnR = BN_CTX_get(bnCtx);
BIGNUM *bnSum = BN_CTX_get(bnCtx);
EC_POINT *ptT1 = NULL;
EC_POINT *ptT2 = NULL;
EC_POINT *ptT3 = NULL;
EC_POINT *ptPk = NULL;
EC_POINT *ptKi = NULL;
EC_POINT *ptL = NULL;
EC_POINT *ptR = NULL;
EC_POINT *ptSi = NULL;
uint8_t tempData[66]; // hold raw point data to hash
uint256 commitHash;
CHashWriter ssCommitHash(SER_GETHASH, PROTOCOL_VERSION);
ssCommitHash << txnHash;
// zero sum
if (!bnSum || !(BN_zero(bnSum)))
{
LogPrintf("%s: BN_zero failed.\n", __func__);
rv = 1; goto End;
};
if ( !(ptT1 = EC_POINT_new(ecGrp))
|| !(ptT2 = EC_POINT_new(ecGrp))
|| !(ptT3 = EC_POINT_new(ecGrp))
|| !(ptPk = EC_POINT_new(ecGrp))
|| !(ptKi = EC_POINT_new(ecGrp))
|| !(ptL = EC_POINT_new(ecGrp))
|| !(ptSi = EC_POINT_new(ecGrp))
|| !(ptR = EC_POINT_new(ecGrp)))
{
LogPrintf("%s: EC_POINT_new failed.\n", __func__);
rv = 1; goto End;
};
// get keyimage as point
if (!(bnT = BN_bin2bn(&keyImage[0], EC_COMPRESSED_SIZE, bnT))
|| !(ptKi) || !(ptKi = EC_POINT_bn2point(ecGrp, bnT, ptKi, bnCtx)))
{
LogPrintf("%s: extract ptKi failed.\n", __func__);
rv = 1; goto End;
};
for (int i = 0; i < nRingSize; ++i)
{
// Li = ci * Pi + ri * G
// Ri = ci * I + ri * Hp(Pi)
if ( !bnC || !(bnC = BN_bin2bn(&pSigc[i * EC_SECRET_SIZE], EC_SECRET_SIZE, bnC))
|| !bnR || !(bnR = BN_bin2bn(&pSigr[i * EC_SECRET_SIZE], EC_SECRET_SIZE, bnR)))
{
LogPrintf("%s: extract bnC and bnR failed.\n", __func__);
rv = 1; goto End;
};
// get Pk i as point
if (!(bnT = BN_bin2bn(&pPubkeys[i * EC_COMPRESSED_SIZE], EC_COMPRESSED_SIZE, bnT))
|| !(ptPk) || !(ptPk = EC_POINT_bn2point(ecGrp, bnT, ptPk, bnCtx)))
{
LogPrintf("%s: extract ptPk failed.\n", __func__);
rv = 1; goto End;
};
// ptT1 = ci * Pi
if (!EC_POINT_mul(ecGrp, ptT1, NULL, ptPk, bnC, bnCtx))
{
LogPrintf("%s: EC_POINT_mul failed.\n", __func__);
rv = 1; goto End;
};
// ptT2 = ri * G
if (!EC_POINT_mul(ecGrp, ptT2, bnR, NULL, NULL, bnCtx))
{
LogPrintf("%s: EC_POINT_mul failed.\n", __func__);
rv = 1; goto End;
};
// ptL = ptT1 + ptT2
if (!EC_POINT_add(ecGrp, ptL, ptT1, ptT2, bnCtx))
{
LogPrintf("%s: EC_POINT_add failed.\n", __func__);
rv = 1; goto End;
};
// ptT3 = Hp(Pi)
if (hashToEC(&pPubkeys[i * EC_COMPRESSED_SIZE], EC_COMPRESSED_SIZE, bnT, ptT3) != 0)
{
LogPrintf("%s: hashToEC failed.\n", __func__);
rv = 1; goto End;
};
// DEBUGGING: ------- check if we can find the signer...
// ptSi = Pi * bnT
if ((!EC_POINT_mul(ecGrp, ptSi, NULL, ptPk, bnT, bnCtx)
|| false)
&& (rv = errorN(1, "%s: EC_POINT_mul failed.1", __func__)))
goto End;
if (0 == EC_POINT_cmp(ecGrp, ptSi, ptKi, bnCtx) )
LogPrintf("signer is index %d\n", i);
// DEBUGGING: - End - check if we can find the signer...
// ptT1 = k1 * I
if (!EC_POINT_mul(ecGrp, ptT1, NULL, ptKi, bnC, bnCtx))
{
LogPrintf("%s: EC_POINT_mul failed.\n", __func__);
rv = 1; goto End;
};
// ptT2 = k2 * ptT3
if (!EC_POINT_mul(ecGrp, ptT2, NULL, ptT3, bnR, bnCtx))
{
LogPrintf("%s: EC_POINT_mul failed.\n", __func__);
rv = 1; goto End;
};
// ptR = ptT1 + ptT2
if (!EC_POINT_add(ecGrp, ptR, ptT1, ptT2, bnCtx))
{
LogPrintf("%s: EC_POINT_add failed.\n", __func__);
rv = 1; goto End;
};
// sum = (sum + ci) % N
if (!BN_mod_add(bnSum, bnSum, bnC, bnOrder, bnCtx))
{
LogPrintf("%s: BN_mod_add failed.\n", __func__);
rv = 1; goto End;
};
// -- add ptL and ptR to hash
if ( !(EC_POINT_point2oct(ecGrp, ptL, POINT_CONVERSION_COMPRESSED, &tempData[0], 33, bnCtx) == (int) EC_COMPRESSED_SIZE)
|| !(EC_POINT_point2oct(ecGrp, ptR, POINT_CONVERSION_COMPRESSED, &tempData[33], 33, bnCtx) == (int) EC_COMPRESSED_SIZE))
{
LogPrintf("%s: extract ptL and ptR failed.\n", __func__);
rv = 1; goto End;
};
ssCommitHash.write((const char*)&tempData[0], 66);
};
commitHash = ssCommitHash.GetHash();
if (!(bnH) || !(bnH = BN_bin2bn(commitHash.begin(), EC_SECRET_SIZE, bnH)))
{
LogPrintf("%s: commitHash -> bnH failed.\n", __func__);
rv = 1; goto End;
};
if (!BN_mod(bnH, bnH, bnOrder, bnCtx))
{
LogPrintf("%s: BN_mod failed.\n", __func__);
rv = 1; goto End;
};
// bnT = (bnH - bnSum) % N
if (!BN_mod_sub(bnT, bnH, bnSum, bnOrder, bnCtx))
{
LogPrintf("%s: BN_mod_sub failed.\n", __func__);
rv = 1; goto End;
};
// test bnT == 0 (bnSum == bnH)
if (!BN_is_zero(bnT))
{
LogPrintf("%s: signature does not verify.\n", __func__);
rv = 2;
};
End:
EC_POINT_free(ptT1);
EC_POINT_free(ptT2);
EC_POINT_free(ptT3);
EC_POINT_free(ptPk);
EC_POINT_free(ptKi);
EC_POINT_free(ptL);
EC_POINT_free(ptR);
EC_POINT_free(ptSi);
BN_CTX_end(bnCtx);
return rv;
};
std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& scriptPubKeyIn, bool fMineWitnessTx)
{
int64_t nTimeStart = GetTimeMicros();
resetBlock();
pblocktemplate.reset(new CBlockTemplate());
if(!pblocktemplate.get())
return nullptr;
pblock = &pblocktemplate->block; // pointer for convenience
// Add dummy coinbase tx as first transaction
pblock->vtx.emplace_back();
pblocktemplate->vTxFees.push_back(-1); // updated at end
pblocktemplate->vTxSigOpsCost.push_back(-1); // updated at end
LOCK2(cs_main, mempool.cs);
CBlockIndex* pindexPrev = chainActive.Tip();
assert(pindexPrev != nullptr);
nHeight = pindexPrev->nHeight + 1;
pblock->nVersion = ComputeBlockVersion(pindexPrev, chainparams.GetConsensus());
// -regtest only: allow overriding block.nVersion with
// -blockversion=N to test forking scenarios
if (chainparams.MineBlocksOnDemand())
pblock->nVersion = gArgs.GetArg("-blockversion", pblock->nVersion);
pblock->nTime = GetAdjustedTime();
const int64_t nMedianTimePast = pindexPrev->GetMedianTimePast();
nLockTimeCutoff = (STANDARD_LOCKTIME_VERIFY_FLAGS & LOCKTIME_MEDIAN_TIME_PAST)
? nMedianTimePast
: pblock->GetBlockTime();
// Decide whether to include witness transactions
// This is only needed in case the witness softfork activation is reverted
// (which would require a very deep reorganization) or when
// -promiscuousmempoolflags is used.
// TODO: replace this with a call to main to assess validity of a mempool
// transaction (which in most cases can be a no-op).
fIncludeWitness = IsWitnessEnabled(pindexPrev, chainparams.GetConsensus()) && fMineWitnessTx;
int nPackagesSelected = 0;
int nDescendantsUpdated = 0;
addPackageTxs(nPackagesSelected, nDescendantsUpdated);
int64_t nTime1 = GetTimeMicros();
nLastBlockTx = nBlockTx;
nLastBlockWeight = nBlockWeight;
// Create coinbase transaction.
CMutableTransaction coinbaseTx;
coinbaseTx.vin.resize(1);
coinbaseTx.vin[0].prevout.SetNull();
coinbaseTx.vout.resize(1);
coinbaseTx.vout[0].scriptPubKey = scriptPubKeyIn;
coinbaseTx.vout[0].nValue = nFees + GetBlockSubsidy(nHeight, chainparams.GetConsensus());
coinbaseTx.vin[0].scriptSig = CScript() << nHeight << OP_0;
pblock->vtx[0] = MakeTransactionRef(std::move(coinbaseTx));
pblocktemplate->vchCoinbaseCommitment = GenerateCoinbaseCommitment(*pblock, pindexPrev, chainparams.GetConsensus());
pblocktemplate->vTxFees[0] = -nFees;
LogPrintf("CreateNewBlock(): block weight: %u txs: %u fees: %ld sigops %d\n", GetBlockWeight(*pblock), nBlockTx, nFees, nBlockSigOpsCost);
// Fill in header
pblock->hashPrevBlock = pindexPrev->GetBlockHash();
UpdateTime(pblock, chainparams.GetConsensus(), pindexPrev);
pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, chainparams.GetConsensus());
pblock->nNonce = 0;
pblocktemplate->vTxSigOpsCost[0] = WITNESS_SCALE_FACTOR * GetLegacySigOpCount(*pblock->vtx[0]);
CValidationState state;
if (!TestBlockValidity(state, chainparams, *pblock, pindexPrev, false, false)) {
throw std::runtime_error(strprintf("%s: TestBlockValidity failed: %s", __func__, FormatStateMessage(state)));
}
int64_t nTime2 = GetTimeMicros();
LogPrint(BCLog::BENCH, "CreateNewBlock() packages: %.2fms (%d packages, %d updated descendants), validity: %.2fms (total %.2fms)\n", 0.001 * (nTime1 - nTimeStart), nPackagesSelected, nDescendantsUpdated, 0.001 * (nTime2 - nTime1), 0.001 * (nTime2 - nTimeStart));
return std::move(pblocktemplate);
}
bool OsmAnd::BinaryMapDataProvider_P::obtainData(
const TileId tileId,
const ZoomLevel zoom,
std::shared_ptr<MapTiledData>& outTiledData,
BinaryMapDataProvider_Metrics::Metric_obtainData* const metric_,
const IQueryController* const queryController)
{
#if OSMAND_PERFORMANCE_METRICS
BinaryMapDataProvider_Metrics::Metric_obtainData localMetric;
const auto metric = metric_ ? metric_ : &localMetric;
#else
const auto metric = metric_;
#endif
std::shared_ptr<TileEntry> tileEntry;
for (;;)
{
// Try to obtain previous instance of tile
_tileReferences.obtainOrAllocateEntry(tileEntry, tileId, zoom,
[]
(const TiledEntriesCollection<TileEntry>& collection, const TileId tileId, const ZoomLevel zoom) -> TileEntry*
{
return new TileEntry(collection, tileId, zoom);
});
// If state is "Undefined", change it to "Loading" and proceed with loading
if (tileEntry->setStateIf(TileState::Undefined, TileState::Loading))
break;
// In case tile entry is being loaded, wait until it will finish loading
if (tileEntry->getState() == TileState::Loading)
{
QReadLocker scopedLcoker(&tileEntry->_loadedConditionLock);
// If tile is in 'Loading' state, wait until it will become 'Loaded'
while (tileEntry->getState() != TileState::Loaded)
REPEAT_UNTIL(tileEntry->_loadedCondition.wait(&tileEntry->_loadedConditionLock));
}
// Try to lock tile reference
outTiledData = tileEntry->_tile.lock();
// If successfully locked, just return it
if (outTiledData)
return true;
// Otherwise consider this tile entry as expired, remove it from collection (it's safe to do that right now)
// This will enable creation of new entry on next loop cycle
_tileReferences.removeEntry(tileId, zoom);
tileEntry.reset();
}
const Stopwatch totalTimeStopwatch(
#if OSMAND_PERFORMANCE_METRICS
true
#else
metric != nullptr
#endif // OSMAND_PERFORMANCE_METRICS
);
// Obtain OBF data interface
const Stopwatch obtainObfInterfaceStopwatch(metric != nullptr);
const auto& dataInterface = owner->obfsCollection->obtainDataInterface();
if (metric)
metric->elapsedTimeForObtainingObfInterface += obtainObfInterfaceStopwatch.elapsed();
// Get bounding box that covers this tile
const auto tileBBox31 = Utilities::tileBoundingBox31(tileId, zoom);
// Perform read-out
const Stopwatch totalReadTimeStopwatch(metric != nullptr);
QList< std::shared_ptr< const ObfMapSectionReader::DataBlock > > referencedMapDataBlocks;
QList< std::shared_ptr<const Model::BinaryMapObject> > referencedMapObjects;
QList< proper::shared_future< std::shared_ptr<const Model::BinaryMapObject> > > futureReferencedMapObjects;
QList< std::shared_ptr<const Model::BinaryMapObject> > loadedMapObjects;
QSet< uint64_t > loadedSharedMapObjects;
auto tileFoundation = MapFoundationType::Undefined;
dataInterface->loadMapObjects(
&loadedMapObjects,
&tileFoundation,
zoom,
&tileBBox31,
[this, zoom, &referencedMapObjects, &futureReferencedMapObjects, &loadedSharedMapObjects, tileBBox31, metric]
(const std::shared_ptr<const ObfMapSectionInfo>& section, const uint64_t id, const AreaI& bbox, const ZoomLevel firstZoomLevel, const ZoomLevel lastZoomLevel) -> bool
{
const Stopwatch objectsFilteringStopwatch(metric != nullptr);
// This map object may be shared only in case it crosses bounds of a tile
const auto canNotBeShared = tileBBox31.contains(bbox);
// If map object can not be shared, just read it
if (canNotBeShared)
{
if (metric)
metric->elapsedTimeForObjectsFiltering += objectsFilteringStopwatch.elapsed();
return true;
}
// Otherwise, this map object can be shared, so it should be checked for
// being present in shared mapObjects storage, or be reserved there
std::shared_ptr<const Model::BinaryMapObject> sharedMapObjectReference;
proper::shared_future< std::shared_ptr<const Model::BinaryMapObject> > futureSharedMapObjectReference;
if (_sharedMapObjects.obtainReferenceOrFutureReferenceOrMakePromise(id, zoom, Utilities::enumerateZoomLevels(firstZoomLevel, lastZoomLevel), sharedMapObjectReference, futureSharedMapObjectReference))
{
if (sharedMapObjectReference)
{
// If map object is already in shared objects cache and is available, use that one
referencedMapObjects.push_back(qMove(sharedMapObjectReference));
}
else
{
futureReferencedMapObjects.push_back(qMove(futureSharedMapObjectReference));
}
if (metric)
metric->elapsedTimeForObjectsFiltering += objectsFilteringStopwatch.elapsed();
return false;
}
// This map object was reserved, and is going to be shared, but needs to be loaded
loadedSharedMapObjects.insert(id);
return true;
},
_dataBlocksCache.get(),
&referencedMapDataBlocks,
nullptr,// query controller
metric ? &metric->loadMapObjectsMetric : nullptr);
// Process loaded-and-shared map objects
for (auto& mapObject : loadedMapObjects)
{
// Check if this map object is shared
if (!loadedSharedMapObjects.contains(mapObject->id))
continue;
// Add unique map object under lock to all zoom levels, for which this map object is valid
assert(mapObject->level);
_sharedMapObjects.fulfilPromiseAndReference(
mapObject->id,
Utilities::enumerateZoomLevels(mapObject->level->minZoom, mapObject->level->maxZoom),
mapObject);
}
for (auto& futureMapObject : futureReferencedMapObjects)
{
auto mapObject = futureMapObject.get();
referencedMapObjects.push_back(qMove(mapObject));
}
if (metric)
metric->elapsedTimeForRead += totalReadTimeStopwatch.elapsed();
// Prepare data for the tile
const auto sharedMapObjectsCount = referencedMapObjects.size() + loadedSharedMapObjects.size();
const auto allMapObjects = loadedMapObjects + referencedMapObjects;
// Create tile
const std::shared_ptr<BinaryMapDataTile> newTile(new BinaryMapDataTile(
_dataBlocksCache,
referencedMapDataBlocks,
tileFoundation,
allMapObjects,
tileId,
zoom));
newTile->_p->_weakLink = _link->getWeak();
newTile->_p->_refEntry = tileEntry;
// Publish new tile
outTiledData = newTile;
// Store weak reference to new tile and mark it as 'Loaded'
tileEntry->_tile = newTile;
tileEntry->setState(TileState::Loaded);
// Notify that tile has been loaded
{
QWriteLocker scopedLcoker(&tileEntry->_loadedConditionLock);
tileEntry->_loadedCondition.wakeAll();
}
if (metric)
{
metric->elapsedTime += totalTimeStopwatch.elapsed();
metric->objectsCount += allMapObjects.size();
metric->uniqueObjectsCount += allMapObjects.size() - sharedMapObjectsCount;
metric->sharedObjectsCount += sharedMapObjectsCount;
}
#if OSMAND_PERFORMANCE_METRICS
#if OSMAND_PERFORMANCE_METRICS <= 1
LogPrintf(LogSeverityLevel::Info,
"%d map objects (%d unique, %d shared) read from %dx%d@%d in %fs",
allMapObjects.size(),
allMapObjects.size() - sharedMapObjectsCount,
sharedMapObjectsCount,
tileId.x,
tileId.y,
zoom,
totalTimeStopwatch.elapsed());
#else
LogPrintf(LogSeverityLevel::Info,
"%d map objects (%d unique, %d shared) read from %dx%d@%d in %fs:\n%s",
allMapObjects.size(),
allMapObjects.size() - sharedMapObjectsCount,
sharedMapObjectsCount,
tileId.x,
tileId.y,
zoom,
totalTimeStopwatch.elapsed(),
qPrintable(metric ? metric->toString(QLatin1String("\t - ")) : QLatin1String("(null)")));
#endif // OSMAND_PERFORMANCE_METRICS <= 1
#endif // OSMAND_PERFORMANCE_METRICS
return true;
}
void PrintLockContention(const char* pszName, const char* pszFile, int nLine)
{
LogPrintf("LOCKCONTENTION: %s\n", pszName);
LogPrintf("Locker: %s:%d\n", pszFile, nLine);
}
/** HTTP request callback */
static void http_request_cb(struct evhttp_request* req, void* arg)
{
// Disable reading to work around a libevent bug, fixed in 2.2.0.
if (event_get_version_number() >= 0x02010600 && event_get_version_number() < 0x02020001) {
evhttp_connection* conn = evhttp_request_get_connection(req);
if (conn) {
bufferevent* bev = evhttp_connection_get_bufferevent(conn);
if (bev) {
bufferevent_disable(bev, EV_READ);
}
}
}
std::unique_ptr<HTTPRequest> hreq(new HTTPRequest(req));
// Early address-based allow check
if (!ClientAllowed(hreq->GetPeer())) {
LogPrint(BCLog::HTTP, "HTTP request from %s rejected: Client network is not allowed RPC access\n",
hreq->GetPeer().ToString());
hreq->WriteReply(HTTP_FORBIDDEN);
return;
}
// Early reject unknown HTTP methods
if (hreq->GetRequestMethod() == HTTPRequest::UNKNOWN) {
LogPrint(BCLog::HTTP, "HTTP request from %s rejected: Unknown HTTP request method\n",
hreq->GetPeer().ToString());
hreq->WriteReply(HTTP_BADMETHOD);
return;
}
LogPrint(BCLog::HTTP, "Received a %s request for %s from %s\n",
RequestMethodString(hreq->GetRequestMethod()), SanitizeString(hreq->GetURI(), SAFE_CHARS_URI).substr(0, 100), hreq->GetPeer().ToString());
// Find registered handler for prefix
std::string strURI = hreq->GetURI();
std::string path;
std::vector<HTTPPathHandler>::const_iterator i = pathHandlers.begin();
std::vector<HTTPPathHandler>::const_iterator iend = pathHandlers.end();
for (; i != iend; ++i) {
bool match = false;
if (i->exactMatch)
match = (strURI == i->prefix);
else
match = (strURI.substr(0, i->prefix.size()) == i->prefix);
if (match) {
path = strURI.substr(i->prefix.size());
break;
}
}
// Dispatch to worker thread
if (i != iend) {
std::unique_ptr<HTTPWorkItem> item(new HTTPWorkItem(std::move(hreq), path, i->handler));
assert(workQueue);
if (workQueue->Enqueue(item.get()))
item.release(); /* if true, queue took ownership */
else {
LogPrintf("WARNING: request rejected because http work queue depth exceeded, it can be increased with the -rpcworkqueue= setting\n");
item->req->WriteReply(HTTP_INTERNAL, "Work queue depth exceeded");
}
} else {
hreq->WriteReply(HTTP_NOTFOUND);
}
}
WalletModel::SendCoinsReturn WalletModel::sendCoins(const QList<SendCoinsRecipient> &recipients, const CCoinControl *coinControl)
{
qint64 total = 0;
QSet<QString> setAddress;
QString hex;
if(recipients.empty())
{
return OK;
}
// Pre-check input data for validity
foreach(const SendCoinsRecipient &rcp, recipients)
{
if(!validateAddress(rcp.address))
{
return InvalidAddress;
}
setAddress.insert(rcp.address);
if(rcp.amount <= 0)
{
return InvalidAmount;
}
total += rcp.amount;
}
if(recipients.size() > setAddress.size())
{
return DuplicateAddress;
}
int64_t nBalance = 0;
std::vector<COutput> vCoins;
wallet->AvailableCoins(vCoins, true, coinControl,false);
for (auto const& out : vCoins)
nBalance += out.tx->vout[out.i].nValue;
if(total > nBalance)
{
return AmountExceedsBalance;
}
if((total + nTransactionFee) > nBalance)
{
return SendCoinsReturn(AmountWithFeeExceedsBalance, nTransactionFee);
}
std::string txid = "";
std::string messages = "";
std::string hashBoinc = "";
{
LOCK2(cs_main, wallet->cs_wallet);
// Sendmany
std::vector<std::pair<CScript, int64_t> > vecSend;
foreach(const SendCoinsRecipient &rcp, recipients)
{
CScript scriptPubKey;
scriptPubKey.SetDestination(CBitcoinAddress(rcp.address.toStdString()).Get());
vecSend.push_back(make_pair(scriptPubKey, rcp.amount));
std::string smessage = MakeSafeMessage(FromQStringW(rcp.Message));
messages += "<MESSAGE>" + smessage + "</MESSAGE>";
}
CWalletTx wtx;
CReserveKey keyChange(wallet);
int64_t nFeeRequired = 0;
if (!msAttachmentGuid.empty())
{
LogPrintf("Adding attachment to tx %s",wtx.hashBoinc);
wtx.hashBoinc += "<ATTACHMENT><TXID>" + wtx.GetHash().ToString() + "</TXID><ATTACHMENTGUID>" + msAttachmentGuid + "</ATTACHMENTGUID></ATTACHMENT>";
}
wtx.hashBoinc += messages;
bool fCreated = wallet->CreateTransaction(vecSend, wtx, keyChange, nFeeRequired, coinControl);
if(!fCreated)
{
if((total + nFeeRequired) > nBalance) // FIXME: could cause collisions in the future
{
return SendCoinsReturn(AmountWithFeeExceedsBalance, nFeeRequired);
}
return TransactionCreationFailed;
}
std::string samt = FormatMoney(wtx.vout[0].nValue);
if(!uiInterface.ThreadSafeAskFee(nFeeRequired, tr("Sending...").toStdString()))
{
return Aborted;
}
if(!wallet->CommitTransaction(wtx, keyChange))
{
return TransactionCommitFailed;
}
hex = QString::fromStdString(wtx.GetHash().GetHex());
txid = wtx.GetHash().GetHex();
hashBoinc = wtx.hashBoinc;
}