// Create and store a network identity.
bool LocalCredentials::nodeIdentityCreate ()
{
if (!getConfig ().QUIET)
std::cerr << "NodeIdentity: Creating." << std::endl;
//
// Generate the public and private key
//
RippleAddress naSeed = RippleAddress::createSeedRandom ();
RippleAddress naNodePublic = RippleAddress::createNodePublic (naSeed);
RippleAddress naNodePrivate = RippleAddress::createNodePrivate (naSeed);
// Make new key.
std::string strDh512 (getRawDHParams (512));
std::string strDh1024 = strDh512;
//
// Store the node information
//
auto db = getApp().getWalletDB ().checkoutDb ();
*db << str (boost::format ("INSERT INTO NodeIdentity (PublicKey,PrivateKey,Dh512,Dh1024) VALUES ('%s','%s',%s,%s);")
% naNodePublic.humanNodePublic ()
% naNodePrivate.humanNodePrivate ()
% sqlEscape (strDh512)
% sqlEscape (strDh1024));
if (!getConfig ().QUIET)
std::cerr << "NodeIdentity: Created." << std::endl;
return true;
}
static void updateRecord(stKVDatabase *database, int64_t key,
const void *value, int64_t sizeOfRecord) {
MySqlDb *dbImpl = database->dbImpl;
char *buf = sqlEscape(dbImpl, value, sizeOfRecord);
sqlExec(dbImpl, "update %s set data=\"%s\" where id=%lld", dbImpl->table, buf, (long long)key);
stSafeCFree(buf);
}
// VFALCO This could be a free function elsewhere
std::string
STTx::getMetaSQL (Serializer rawTxn,
std::uint32_t inLedger, char status, std::string const& escapedMetaData) const
{
static boost::format bfTrans ("('%s', '%s', '%s', '%d', '%d', '%c', %s, %s)");
std::string rTxn = sqlEscape (rawTxn.peekData ());
auto format = TxFormats::getInstance().findByType (tx_type_);
assert (format != nullptr);
return str (boost::format (bfTrans)
% to_string (getTransactionID ()) % format->getName ()
% toBase58(getAccountID(sfAccount))
% getSequence () % inLedger % status % rTxn % escapedMetaData);
}
/* ------------------------------------------------------------- */
static int insertMarkerValue (PUCHAR buf , PUCHAR marker, PJXNODE parms)
{
int len =0;
PJXNODE pNode;
PUCHAR value;
pNode = jx_GetNode ( parms , marker);
if (pNode) {
value = jx_GetValuePtr ( pNode , "" , NULL );
if (pNode->isLiteral) {
strcpy(buf, value);
len = strlen(buf);
} else {
len = sqlEscape (buf , value);
}
}
return len;
}
static void insertRecord(stKVDatabase *database, int64_t key, const void *value, int64_t sizeOfRecord) {
MySqlDb *dbImpl = database->dbImpl;
char *buf = sqlEscape(dbImpl, value, sizeOfRecord);
sqlExec(dbImpl, "insert into %s (id, data) values (%lld, \"%s\")", dbImpl->table, (long long)key, buf);
stSafeCFree(buf);
}
static void insertInt64(stKVDatabase *database, int64_t key, int64_t value) {
MySqlDb *dbImpl = database->dbImpl;
char *buf = sqlEscape(dbImpl, &value, sizeof(int64_t));
sqlExec(dbImpl, "insert into %s (id, data) values (%lld, \"%s\")", dbImpl->table, (long long)key, buf);
}
static void updateInt64(stKVDatabase *database, int64_t key, int64_t value) {
MySqlDb *dbImpl = database->dbImpl;
char *buf = sqlEscape(dbImpl, &value, sizeof(int64_t));
sqlExec(dbImpl, "update %s set data=\"%s\" where id=%lld", dbImpl->table, buf, (long long)key);
}
std::string AcceptedLedgerTx::getEscMeta () const
{
assert (!mRawMeta.empty ());
return sqlEscape (mRawMeta);
}
void HashedObjectStore::bulkWrite()
{
while (1)
{
std::vector< boost::shared_ptr<HashedObject> > set;
set.reserve(128);
{
boost::mutex::scoped_lock sl(mWriteMutex);
mWriteSet.swap(set);
assert(mWriteSet.empty());
++mWriteGeneration;
mWriteCondition.notify_all();
if (set.empty())
{
mWritePending = false;
return;
}
}
// cLog(lsTRACE) << "HOS: writing " << set.size();
#ifndef NO_SQLITE3_PREPARE
{
Database* db = theApp->getHashNodeDB()->getDB();
ScopedLock sl(theApp->getHashNodeDB()->getDBLock());
static SqliteStatement pSt(db->getSqliteDB(),
"INSERT OR IGNORE INTO CommittedObjects "
"(Hash,ObjType,LedgerIndex,Object) VALUES (?, ?, ?, ?);");
db->executeSQL("BEGIN TRANSACTION;");
BOOST_FOREACH(const boost::shared_ptr<HashedObject>& it, set)
{
const char* type;
switch (it->getType())
{
case hotLEDGER: type = "L"; break;
case hotTRANSACTION: type = "T"; break;
case hotACCOUNT_NODE: type = "A"; break;
case hotTRANSACTION_NODE: type = "N"; break;
default: type = "U";
}
pSt.reset();
pSt.bind(1, it->getHash().GetHex());
pSt.bind(2, type);
pSt.bind(3, it->getIndex());
pSt.bindStatic(4, it->getData());
int ret = pSt.step();
if (!pSt.isDone(ret))
{
cLog(lsFATAL) << "Error saving hashed object " << ret;
assert(false);
}
}
db->executeSQL("END TRANSACTION;");
}
#else
static boost::format
fAdd("INSERT OR IGNORE INTO CommittedObjects "
"(Hash,ObjType,LedgerIndex,Object) VALUES ('%s','%c','%u',%s);");
Database* db = theApp->getHashNodeDB()->getDB();
{
ScopedLock sl(theApp->getHashNodeDB()->getDBLock());
db->executeSQL("BEGIN TRANSACTION;");
BOOST_FOREACH(const boost::shared_ptr<HashedObject>& it, set)
{
char type;
switch (it->getType())
{
case hotLEDGER: type = 'L'; break;
case hotTRANSACTION: type = 'T'; break;
case hotACCOUNT_NODE: type = 'A'; break;
case hotTRANSACTION_NODE: type = 'N'; break;
default: type = 'U';
}
db->executeSQL(boost::str(fAdd % it->getHash().GetHex() % type % it->getIndex() % sqlEscape(it->getData())));
}
db->executeSQL("END TRANSACTION;");
}
#endif
}
