bool OTToken::GetPrototoken(OTASCIIArmor & ascPrototoken, int nTokenIndex)
{
// out of bounds. For a count 10 element array, index 10 is out of bounds.
// thus if attempted index is equal or larger to the count, out of bounds.
if (nTokenIndex >= m_nTokenCount)
{
return false;
}
// OTLog::vError("DEBUG OTToken::GetPrototoken. nTokenIndex is %d. m_nTokenCount is %d\n------------------------\n",
// nTokenIndex, m_nTokenCount);
// loop through the items that make up this transaction and print them out here, base64-encoded, of course.
OTASCIIArmor * pPrototoken = NULL;
for (mapOfPrototokens::iterator ii = m_mapPublic.begin(); ii != m_mapPublic.end(); ++ii)
{
pPrototoken = (*ii).second;
OT_ASSERT(NULL != pPrototoken);
const bool bSuccess = (nTokenIndex == (*ii).first);
// OTLog::vError("DEBUG OTToken::GetPrototoken ABOUT TO ENTER, index: %d\n", nTokenIndex);
if (bSuccess)
{
ascPrototoken.Set(*pPrototoken);
// OTLog::vError("DEBUG OTToken::GetPrototoken INNER SANCTUM\n PROTOKEN:"
// "\n-----------%s-----------\n", ascPrototoken.Get());
return true;
}
}
return false;
}
bool OTToken::GetPrivatePrototoken(OTASCIIArmor & ascPrototoken, int nTokenIndex)
{
// out of bounds. For a count 10 element array, index 10 is out of bounds.
// thus if attempted index is equal or larger to the count, out of bounds.
if (nTokenIndex >= m_nTokenCount)
{
return false;
}
// loop through the items that make up this transaction and print them out here, base64-encoded, of course.
OTASCIIArmor * pPrototoken = NULL;
for (mapOfPrototokens::iterator ii = m_mapPrivate.begin(); ii != m_mapPrivate.end(); ++ii)
{
pPrototoken = (*ii).second;
OT_ASSERT(NULL != pPrototoken);
const bool bSuccess = (nTokenIndex == (*ii).first);
if (bSuccess)
{
ascPrototoken.Set(*pPrototoken);
return true;
}
}
return false;
}
QString MTContactHandler::GetContactName(int nContactID)
{
QMutexLocker locker(&m_Mutex);
QString str_select = QString("SELECT `contact_display_name` FROM `contact` WHERE `contact_id`='%1' LIMIT 0,1").arg(nContactID);
int nRows = DBHandler::getInstance()->querySize(str_select);
for(int ii=0; ii < nRows; ii++)
{
//Extract data
QString contact_name = DBHandler::getInstance()->queryString(str_select, 0, ii);
if (!contact_name.isEmpty())
{
// qDebug() << QString("About to decode name: %1").arg(contact_name);
//Decode base64.
OTASCIIArmor ascName;
ascName.Set(contact_name.toStdString().c_str());
OTString strName(ascName);
contact_name = QString(strName.Get());
}
//---------------------------------------------------
return contact_name; // In practice there should only be one row.
}
return ""; // Didn't find anyone.
}
// Let's say you don't know if the input string is raw base64, or if it has
// bookends
// on it like -----BEGIN BLAH BLAH ...
// And if it DOES have Bookends, you don't know if they are escaped: -
// -----BEGIN ...
// Let's say you just want an easy function that will figure that crap out, and
// load the
// contents up properly into an OTASCIIArmor object. (That's what this function
// will do.)
//
// str_bookend is a default.
// So you could make it more specific like, -----BEGIN ENCRYPTED KEY (or
// whatever.)
//
// static
bool OTASCIIArmor::LoadFromString(OTASCIIArmor& ascArmor,
const String& strInput,
std::string str_bookend)
{
if (strInput.Contains(str_bookend)) // YES there are bookends around this.
{
const std::string str_escaped("- " + str_bookend);
const bool bEscaped = strInput.Contains(str_escaped);
String strLoadFrom(strInput);
if (!ascArmor.LoadFromString(strLoadFrom, bEscaped)) // removes the
// bookends so we
// have JUST the
// coded part.
{
// otErr << "%s: Failure loading string into OTASCIIArmor
// object:\n\n%s\n\n",
// __FUNCTION__, strInput.Get());
return false;
}
}
else
ascArmor.Set(strInput.Get());
return true;
}
// Envelope retrieved from payload.
bool OTPayload::GetEnvelope(OTEnvelope & theEnvelope) const
{
// validate checksum
uint32_t lSize = GetSize();
uint32_t lIndex = lSize-2; // the index to where the NULL terminator SHOULD be if they
// sent us a base64-encoded string, containing an encrypted message. (which we expect...)
// (lSize-1 would be the location of the checksum at the end.)
if (0 == lSize)
return false;
if (IsChecksumValid((OT_BYTE*)GetPointer(), (uint32_t)lSize))
{
// We add the null-terminator ourselves at this point, for security reasons,
// since we will process the data, soon after this function, as a string.
((OT_BYTE *)GetPointer())[lIndex] = 0;
theEnvelope.m_dataContents.Release();
OTASCIIArmor theArmor;
// Why is this safe, where I cast the Payload data pointer as
// a char * and tell the data object to set itself from that?
// Because (1) I just validated the checksum, and
// (2) There place where the NULL should be, I set to 0, by hand,
// just above 2 lines. So when this set operation occurs, the
// farthest it will go is to that 0.
theArmor.Set((const char *)GetPointer());
// Todo NOTE: If I ever want to process bookends here instead of assuming they aren't there,
// IT'S VERY EASY!! All I have to do is call theArmor.LoadFromString instead of theArmor.Set.
// Now the ascii-armored string that was sent across is decoded back to binary into the
// Envelope object.
theEnvelope.SetAsciiArmoredData(theArmor);
return true;
}
else
{
OTLog::Error("Invalid Checksum in OTPayload::GetEnvelope\n");
return false;
}
}
// The contact ID (unlike all the other IDs) is an int instead of a string.
// Therefore we just convert it to a string and return it in a map in the same
// format as all the others.
// (FYI.)
//
bool MTContactHandler::GetContacts(mapIDName & theMap)
{
QMutexLocker locker(&m_Mutex);
QString str_select = QString("SELECT * FROM contact");
bool bFoundAny = false;
int nRows = DBHandler::getInstance()->querySize(str_select);
for(int ii=0; ii < nRows; ii++)
{
int contact_id = DBHandler::getInstance()->queryInt (str_select, 0, ii);
QString contact_name = DBHandler::getInstance()->queryString(str_select, 1, ii);
if (contact_id > 0)
{
bFoundAny = true;
QString str_contact_id;
str_contact_id = QString("%1").arg(contact_id);
if (!contact_name.isEmpty())
{
// qDebug() << QString("About to decode name: %1").arg(contact_name);
//Decode base64.
OTASCIIArmor ascName;
ascName.Set(contact_name.toStdString().c_str());
OTString strName(ascName);
contact_name = QString(strName.Get());
}
// --------------------------------------------------
// At this point we have the contact ID (in string form) *and* the contact name.
// So we can add them to our map...
theMap.insert(str_contact_id, contact_name);
}
}
// ---------------------------------------------------------------------
return bFoundAny;
}
bool MTContactHandler::GetNyms(mapIDName & theMap, int nFilterByContact) //resume
{
QMutexLocker locker(&m_Mutex);
QString str_select = QString("SELECT * FROM `nym` WHERE `contact_id`='%1'").arg(nFilterByContact);
// QString str_select = QString("SELECT * FROM `nym` WHERE `contact_id`='%1' LIMIT 0,1").arg(nFilterByContact);
bool bFoundAny = false;
int nRows = DBHandler::getInstance()->querySize(str_select);
for (int ii=0; ii < nRows; ii++)
{
QString nym_id = DBHandler::getInstance()->queryString(str_select, 0, ii);
QString nym_name = DBHandler::getInstance()->queryString(str_select, 2, ii);
if (!nym_id.isEmpty())
{
bFoundAny = true;
if (!nym_name.isEmpty())
{
// qDebug() << QString("About to decode name: %1").arg(nym_name);
//Decode base64.
OTASCIIArmor ascName;
ascName.Set(nym_name.toStdString().c_str());
OTString strName(ascName);
nym_name = QString(strName.Get());
}
// ----------------------------
// At this point we have the nym ID *and* the nym name.
// So we can add them to our map...
theMap.insert(nym_id, nym_name);
}
}
// ---------------------------------------------------------------------
return bFoundAny;
}
// Let's say you don't know if the input string is raw base64, or if it has bookends
// on it like -----BEGIN BLAH BLAH ...
// And if it DOES have Bookends, you don't know if they are escaped: - -----BEGIN ...
// Let's say you just want an easy function that will figure that crap out, and load the
// contents up properly into an OTASCIIArmor object. (That's what this function will do.)
//
// str_bookend is a default.
// So you could make it more specific like, -----BEGIN ENCRYPTED KEY (or whatever.)
//
//static
bool OTASCIIArmor::LoadFromString(OTASCIIArmor & ascArmor, const OTString & strInput, const std::string str_bookend/*="-----BEGIN"*/)
{
// -----------------------------------------------------
if (strInput.Contains(str_bookend)) // YES there are bookends around this.
{
const std::string str_escaped("- " + str_bookend);
// -----------------------------------
const bool bEscaped = strInput.Contains(str_escaped);
// -----------------------------------
OTString strLoadFrom(strInput);
if (!ascArmor.LoadFromString(strLoadFrom, bEscaped)) // removes the bookends so we have JUST the coded part.
{
// OTLog::vError("%s: Failure loading string into OTASCIIArmor object:\n\n%s\n\n",
// __FUNCTION__, strInput.Get());
return false;
}
}
else
ascArmor.Set(strInput.Get());
// -------------------------------------------------
return true;
}
inline void SetSpendable(const OTASCIIArmor & theArmor) {
m_ascSpendable.Set(theArmor);
}
int OTSignedFile::ProcessXMLNode(irr::io::IrrXMLReader*& xml)
{
int nReturnVal = 0;
// Here we call the parent class first.
// If the node is found there, or there is some error,
// then we just return either way. But if it comes back
// as '0', then nothing happened, and we'll continue executing.
//
// -- Note you can choose not to call the parent if
// you don't want to use any of those xml tags.
// As I do below, in the case of OTAccount.
//if (nReturnVal = OTContract::ProcessXMLNode(xml))
// return nReturnVal;
if (!strcmp("signedFile", xml->getNodeName()))
{
m_strVersion = xml->getAttributeValue("version");
m_strPurportedLocalDir = xml->getAttributeValue("localDir");
m_strPurportedFilename = xml->getAttributeValue("filename");
// ---------------------
nReturnVal = 1;
}
else if (!strcmp("filePayload", xml->getNodeName()))
{
// go to the next node and read the text.
xml->read();
if (EXN_TEXT == xml->getNodeType())
{
OTString strNodeData = xml->getNodeData();
// Sometimes the XML reads up the data with a prepended newline.
// This screws up my own objects which expect a consistent in/out
// So I'm checking here for that prepended newline, and removing it.
char cNewline;
if (strNodeData.At(0, cNewline))
{
OTASCIIArmor ascNodeData;
if ('\n' == cNewline)
{
ascNodeData.Set(strNodeData.Get() + 1);
ascNodeData.GetString(m_strSignedFilePayload, true); // linebreaks = true
}
else
{
ascNodeData.Set(strNodeData.Get());
ascNodeData.GetString(m_strSignedFilePayload, true); // linebreaks = true
}
}
}
else {
fprintf(stderr, "Error in OTSignedFile::ProcessXMLNode: filePayload field without value.\n");
return (-1); // error condition
}
return 1;
}
return nReturnVal;
}
bool MainFile::CreateMainFile(const std::string& strContract,
const std::string& strNotaryID,
const std::string& strCert,
const std::string& strNymID,
const std::string& strCachedKey)
{
if (!OTDB::StorePlainString(strContract, "contracts", strNotaryID)) {
Log::Error("Failed trying to store the server contract.\n");
return false;
}
if (!strCert.empty() &&
!OTDB::StorePlainString(strCert, "certs", strNymID)) {
Log::Error(
"Failed trying to store the server Nym's public/private cert.\n");
return false;
}
const char* szBlankFile = // todo hardcoding.
"<notaryServer version=\"2.0\"\n"
" notaryID=\"%s\"\n"
" serverNymID=\"%s\"\n"
" transactionNum=\"%ld\" >\n"
"\n"
"<cachedKey>\n"
"%s</cachedKey>\n"
"\n"
"<accountList type=\"voucher\" count=\"0\" >\n"
"\n"
"</accountList>\n"
"\n"
"</notaryServer>\n\n";
int64_t lTransNum = 5; // a starting point, for the new server.
String strNotaryFile;
strNotaryFile.Format(szBlankFile, strNotaryID.c_str(), strNymID.c_str(),
lTransNum, strCachedKey.c_str());
std::string str_Notary(strNotaryFile.Get());
if (!OTDB::StorePlainString(str_Notary, ".",
"notaryServer.xml")) // todo hardcoding.
{
Log::Error("Failed trying to store the new notaryServer.xml file.\n");
return false;
}
OTASCIIArmor ascCachedKey;
ascCachedKey.Set(strCachedKey.c_str());
OTCachedKey::It()->SetCachedKey(ascCachedKey);
if (!OTCachedKey::It()->HasHashCheck()) {
OTPassword tempPassword;
tempPassword.zeroMemory();
std::shared_ptr<OTCachedKey> sharedPtr(OTCachedKey::It());
sharedPtr->GetMasterPassword(
sharedPtr, tempPassword,
"We do not have a check hash yet for this password, "
"please enter your password",
true);
if (!SaveMainFile()) {
OT_FAIL;
}
}
// At this point, the contract is saved, the cert is saved, and the
// notaryServer.xml file
// is saved. All we have left is the Nymfile, which we'll create.
const String strServerNymID(strNymID.c_str());
server_->m_nymServer.SetIdentifier(strServerNymID);
if (!server_->m_nymServer.LoadCredentials(true)) {
Log::vOutput(0, "%s: Error loading server credentials, or "
"certificate and private key.\n",
__FUNCTION__);
}
else if (!server_->m_nymServer.VerifyPseudonym()) {
Log::vOutput(0, "%s: Error verifying server nym. Are you sure you "
"have the right ID?\n",
__FUNCTION__);
}
else if (!server_->m_nymServer.SaveSignedNymfile(server_->m_nymServer)) {
Log::vOutput(0, "%s: Error saving new nymfile for server nym.\n",
__FUNCTION__);
}
else {
Log::vOutput(0, "%s: OKAY, we have apparently created the new "
"server.\n"
"Let's try to load up your new server contract...\n",
__FUNCTION__);
return true;
}
return false;
}
// LoadContract will call this function at the right time.
// return -1 if error, 0 if nothing, and 1 if the node was processed.
int OTLedger::ProcessXMLNode(irr::io::IrrXMLReader*& xml)
{
OTString strKeyName;
OTString strKeyValue;
OTString strTransaction;
OTASCIIArmor ascTransaction;
if (!strcmp("accountLedger", xml->getNodeName()))
{
OTString strType, strLedgerAcctID, strLedgerAcctServerID, strUserID;
strType = xml->getAttributeValue("type");
if (strType.Compare("message"))
m_Type = OTLedger::message;
else if (strType.Compare("inbox"))
m_Type = OTLedger::inbox;
else if (strType.Compare("outbox"))
m_Type = OTLedger::outbox;
else if (strType.Compare("nymbox"))
m_Type = OTLedger::nymbox;
else
m_Type = OTLedger::error_state;
m_strVersion = xml->getAttributeValue("version");
strLedgerAcctID = xml->getAttributeValue("accountID");
strLedgerAcctServerID = xml->getAttributeValue("serverID");
strUserID = xml->getAttributeValue("userID");
OTIdentifier ACCOUNT_ID(strLedgerAcctID), SERVER_ID(strLedgerAcctServerID), USER_ID(strUserID);
SetPurportedAccountID(ACCOUNT_ID);
SetPurportedServerID(SERVER_ID);
SetUserID(USER_ID);
OTLog::vOutput(2, "Loaded account ledger of type \"%s\", version: %s\n",
// "accountID:\n%s\n userID:\n%s\n serverID:\n%s\n----------\n",
strType.Get(),
m_strVersion.Get()
// strLedgerAcctID.Get(), strUserID.Get(), strLedgerAcctServerID.Get()
);
// Since we just loaded this stuff, let's verify it.
// We may have to remove this verification here and do it outside this call.
// But for now...
if (VerifyContractID())
return 1;
else {
return -1;
}
}
else if (!strcmp("transaction", xml->getNodeName()))
{
// go to the next node and read the text.
xml->read();
if (EXN_TEXT == xml->getNodeType())
{
// the ledger contains a series of transactions.
// Each transaction is initially stored as an OTASCIIArmor string.
ascTransaction.Set(xml->getNodeData()); // Put the ascii-armored node data into the ascii-armor object
ascTransaction.GetString(strTransaction); // Decode that into strTransaction, so we can load the transaction object from that string.
OTTransaction * pTransaction = new OTTransaction(GetUserID(), GetPurportedAccountID(), GetPurportedServerID());
// If we're able to successfully base64-decode the string and load it up as
// a transaction, then let's add it to the ledger's list of transactions
if (pTransaction && pTransaction->LoadContractFromString(strTransaction)
&& pTransaction->VerifyContractID())
// I responsible here to call pTransaction->VerifyContract() since
// I am loading it here and adding it to the ledger. (So I do.)
{
m_mapTransactions[pTransaction->GetTransactionNum()] = pTransaction;
// OTLog::Output(5, "Loaded transaction and adding to m_mapTransactions in OTLedger\n");
}
else {
OTLog::Error("ERROR: loading transaction in OTLedger::ProcessXMLNode\n");
if (pTransaction)
{
delete pTransaction;
pTransaction = NULL;
}
return (-1);
}
}
else {
OTLog::Error("Error in OTLedger::ProcessXMLNode: transaction without value.\n");
return (-1); // error condition
}
return 1;
}
return 0;
}
bool MTContactHandler::GetAccounts(mapIDName & theMap, QString filterByNym, QString filterByServer, QString filterByAsset)
{
QMutexLocker locker(&m_Mutex);
// -------------------------
mapIDName parameters;
// -------------------------
if (!filterByNym.isEmpty())
parameters.insert("nym_id", filterByNym);
// -------------------------
if (!filterByServer.isEmpty())
parameters.insert("server_id", filterByServer);
// -------------------------
if (!filterByAsset.isEmpty())
parameters.insert("asset_id", filterByAsset);
// -------------------------
// Construct the WHERE clause.
//
QString strParams;
int nIteration = 0;
while (!parameters.empty())
{
nIteration++; // 1 on first iteration.
// ----------------------------------
mapIDName::iterator the_beginning = parameters.begin();
if (parameters.end() == the_beginning)
break; // Done.
// ----------------------------------
QString strKey = the_beginning.key();
QString strValue = the_beginning.value();
// ----------------------------------
if (1 == nIteration) // first iteration
{
strParams = QString(" WHERE `%1`='%2'").arg(strKey).arg(strValue);
}
else // subsequent iterations.
{
strParams += QString(" AND `%1`='%2'").arg(strKey).arg(strValue);
}
// ----------------------------------
parameters.remove(strKey);
} // while
// ---------------------------------
// Construct the SELECT statement and append the WHERE clause.
//
QString str_select = QString("SELECT * FROM `nym_account`");
if (!strParams.isEmpty())
str_select += strParams;
// ---------------------------------
bool bFoundAccounts = false;
int nRows = DBHandler::getInstance()->querySize(str_select);
for(int ii=0; ii < nRows; ii++)
{
QString account_id = DBHandler::getInstance()->queryString(str_select, 0, ii);
QString account_nym_id = DBHandler::getInstance()->queryString(str_select, 2, ii);
QString display_name = DBHandler::getInstance()->queryString(str_select, 4, ii);
if (!display_name.isEmpty())
{
// qDebug() << QString("About to decode name: %1").arg(display_name);
//Decode base64.
OTASCIIArmor ascName;
ascName.Set(display_name.toStdString().c_str());
OTString strName(ascName);
display_name = QString(strName.Get());
}
//---------------------------------------------------
if (!account_id.isEmpty()) // Account ID is present.
{
if (display_name.isEmpty()) // Display name isn't.
{
// Look up the display name for the contact who owns the Nym who owns the Acct.
//
if (!account_nym_id.isEmpty())
{
int nContactID = this->FindContactIDByNymID(account_nym_id);
if (nContactID > 0)
{
display_name = this->GetContactName(nContactID);
}
}
}
// ----------------------
if (display_name.isEmpty()) // Display name isn't.
{
display_name = account_id;
}
// ----------------------
bFoundAccounts = true;
theMap.insert(account_id, display_name);
}
} // for
// ---------------------------------
return bFoundAccounts;
}