opentxs::OTMessageOutbuffer Class Reference

#include <OTMessageOutbuffer.hpp>

Public Member Functions
EXPORT	OTMessageOutbuffer ()
EXPORT	~OTMessageOutbuffer ()
EXPORT void	Clear (const OTString *serverId=nullptr, const OTString *nymId=nullptr, OTPseudonym *nym=nullptr, const bool *harvestingForRetry=nullptr)
EXPORT void	AddSentMessage (OTMessage &message)
EXPORT OTMessage *	GetSentMessage (const int64_t &requestNum, const OTString &serverId, const OTString &nymId)
EXPORT bool	RemoveSentMessage (const int64_t &requestNum, const OTString &serverId, const OTString &nymId)
EXPORT OTMessage *	GetSentMessage (const OTTransaction &transaction)
EXPORT bool	RemoveSentMessage (const OTTransaction &transaction)

Detailed Description

Definition at line 167 of file OTMessageOutbuffer.hpp.

Constructor & Destructor Documentation

opentxs::OTMessageOutbuffer::OTMessageOutbuffer

(

)

Definition at line 163 of file OTMessageOutbuffer.cpp.

    : dataFolder_(OTDataFolder::Get())
{
    OT_ASSERT(dataFolder_.Exists());
}

opentxs::OTMessageOutbuffer::~OTMessageOutbuffer

(

)

Definition at line 842 of file OTMessageOutbuffer.cpp.

{
    Clear();
}

Member Function Documentation

void opentxs::OTMessageOutbuffer::AddSentMessage

(

OTMessage &

message

)

Definition at line 169 of file OTMessageOutbuffer.cpp.

{
    int64_t lRequestNum = 0;

    if (theMessage.m_strRequestNum.Exists())
        lRequestNum = atol(theMessage.m_strRequestNum.Get()); // The map index
                                                              // is the request
                                                              // number on the
                                                              // message itself.

    // It's technically possible to have TWO messages (from two different
    // servers) that happen to have the same request number. So we verify
    // that here, before removing any old ones with the same number and IDs.
    //
    auto it = messagesMap_.begin();

    for (; it != messagesMap_.end(); ++it) {

        const int64_t& lTempReqNum = it->first;

        if (lTempReqNum != lRequestNum) {
            continue;
        }

        OTMessage* pMsg = it->second;
        OT_ASSERT(nullptr != pMsg);

        //
        // If a server ID was passed in, but doesn't match the server ID on this
        // message,
        // Then skip this one. (Same with the NymID.)
        //
        if (!theMessage.m_strServerID.Compare(pMsg->m_strServerID) ||
            !theMessage.m_strNymID.Compare(pMsg->m_strNymID)) {
            continue;
        }
        else {
            delete pMsg;
            pMsg = nullptr;
            messagesMap_.erase(it);
            break;
        }
    }
    // Whatever it was, it's gone now!

    // Now that we KNOW there's nothing already there with that request number
    // (for that
    // server ID and Nym ID), we go ahead and add the new message to the map.
    // (And take ownership.)
    //
    messagesMap_.insert(
        std::pair<int64_t, OTMessage*>(lRequestNum, &theMessage));

    //
    // Save it to local storage, in case we don't see the reply until the next
    // run.
    //
    bool bAlreadyExists = false, bIsNewFolder = false;
    OTString strFolder, strFolder1, strFolder2;
    strFolder1.Format("%s%s%s", OTFolders::Nym().Get(), OTLog::PathSeparator(),
                      theMessage.m_strServerID.Get());
    strFolder2.Format("%s%s%s", strFolder1.Get(), OTLog::PathSeparator(),
                      "sent" /*todo hardcoding*/);

    strFolder.Format("%s%s%s", strFolder2.Get(), OTLog::PathSeparator(),
                     theMessage.m_strNymID.Get());

    OTString strFolderPath = "", strFolder1Path = "", strFolder2Path = "";

    OTPaths::AppendFolder(strFolderPath, dataFolder_, strFolder);
    OTPaths::AppendFolder(strFolder1Path, dataFolder_, strFolder1);
    OTPaths::AppendFolder(strFolder2Path, dataFolder_, strFolder2);

    OTPaths::ConfirmCreateFolder(strFolderPath, bAlreadyExists, bIsNewFolder);
    OTPaths::ConfirmCreateFolder(strFolder1Path, bAlreadyExists, bIsNewFolder);
    OTPaths::ConfirmCreateFolder(strFolder2Path, bAlreadyExists, bIsNewFolder);

    OTString strFile;
    strFile.Format("%s.msg", theMessage.m_strRequestNum.Get());

    theMessage.SaveContract(strFolder.Get(), strFile.Get());

    // We also keep a list of the request numbers, so let's load it up, add the
    // number
    // to that list, and then save it again.
    //
    OTNumList theNumList;
    std::string str_data_filename("sent.dat"); // todo hardcoding.
    if (OTDB::Exists(strFolder.Get(), str_data_filename)) {
        OTString strNumList(
            OTDB::QueryPlainString(strFolder.Get(), str_data_filename));
        if (strNumList.Exists()) theNumList.Add(strNumList);
        theNumList.Add(lRequestNum); // Add the new request number to it.
    }
    else // it doesn't exist on disk, so let's just create it from the list we
           // have in RAM so we can store it to disk.
    {
        it = messagesMap_.begin();
        while (it != messagesMap_.end()) {

            const int64_t& lTempReqNum = it->first;

            OTMessage* pMsg = it->second;
            OT_ASSERT(nullptr != pMsg);

            //
            // If a server ID was passed in, but doesn't match the server ID on
            // this message,
            // Then skip this one. (Same with the NymID.)
            //
            if (!theMessage.m_strServerID.Compare(pMsg->m_strServerID) ||
                !theMessage.m_strNymID.Compare(pMsg->m_strNymID)) {
                ++it;
                continue;
            }
            else {
                theNumList.Add(lTempReqNum);
            }
            ++it;
        }
    } // else

    // By this point, theNumList has either been loaded from local storage and
    // had the new number added,
    // or it wasn't in local storage and thus we created it and added all the
    // numnbers to it (including new one.)
    // Therefore nothing left to do here, but save it back again!
    //
    OTString strOutput;
    theNumList.Output(strOutput);

    if (!OTDB::StorePlainString(strOutput.Get(), strFolder.Get(),
                                str_data_filename)) // todo hardcoding.
    {
        otErr << "OTMessageOutbuffer::AddSentMessage: Error: failed writing "
                 "list of request numbers to storage.\n";
    }
}

void opentxs::OTMessageOutbuffer::Clear	(	const OTString *	serverId = nullptr,
		const OTString *	nymId = nullptr,
		OTPseudonym *	nym = nullptr,
		const bool *	harvestingForRetry = nullptr
	)

Definition at line 395 of file OTMessageOutbuffer.cpp.

{
    //  const char * szFuncName        = "OTMessageOutbuffer::Clear";

    auto it = messagesMap_.begin();

    while (it != messagesMap_.end()) {

        const int64_t& lRequestNum = it->first;
        OTMessage* pThisMsg = it->second;
        OT_ASSERT(nullptr != pThisMsg);

        //
        // If a server ID was passed in, but doesn't match the server ID on this
        // message,
        // Then skip this one. (Same with the NymID.)
        if (((nullptr != pstrServerID) &&
             !pstrServerID->Compare(pThisMsg->m_strServerID)) ||
            ((nullptr != pstrNymID) &&
             !pstrNymID->Compare(pThisMsg->m_strNymID))) {
            ++it;
            continue;
        }
        else {
            /*
             Sent messages are cached because some of them are so important,
             that
             the server drops a reply notice into the Nymbox to make sure they
             were
             received. This way, when we download the Nymbox we can SEE which
             messages
             were ACTUALLY replied to, and at that time, we removed those
             messages
             already from *this "sent buffer." After that loop was done, we
             called
             CLEAR (this function) and cleared ALL the sent messages from the
             buffer
             (for the appropriate server and nym IDs...clear without those IDs
             is
             only for the destructor.)

             This Clear, where we are now, HARVESTS the transaction numbers back
             from any messages left in the sent buffer. We are able to do this
             with
             confidence because we know that this function is only called in
             @getNymbox
             on client side, and only after the ones with actual replies (as
             evidenced
             by the Nymbox) have already been removed from *this "sent buffer."

             Why were they removed in advance? Because clearly: if the server
             HAS replied
             to them already, then there's no need to harvest anything: just let
             it
             process as normal, whether the transaction inside is a success or
             fail.
             (We KNOW the message didn't fail because otherwise there wouldn't
             even be
             a notice in the Nymbox. So this is about the transaction inside.)

             So we remove the ones that we DEFINITELY know the server HAS
             replied to.

             And the ones remaining? We know for those, the server definitely
             has NOT
             replied to them (the message must have been dropped by the network
             or
             something.) How do we know this? Because there would be a notice in
             the
             Nymbox! So at the moment of successful @getNymbox, we are able to
             loop through
             those receipts and know FOR SURE, WHICH ones definitely have a
             reply, and
             which ones definitely DO NOT.

             The ones where we definitely do NOT have a reply--that is, the ones
             that are in
             the "sent messages" buffer, but are not in the Nymbox with the same
             request
             number--we harvest those numbers, since the server clearly never
             saw them, or
             rejected the message before the transaction itself even had a
             chance to run.

             */
            if (nullptr != pNym) {
                OT_ASSERT(nullptr != pstrNymID && pstrNymID->Exists());
                const OTIdentifier MSG_NYM_ID(*pstrNymID);
                OT_ASSERT(pNym->CompareID(MSG_NYM_ID));

                OT_ASSERT(nullptr != pstrServerID && pstrServerID->Exists());

                OT_ASSERT(nullptr != pbHarvestingForRetry);

                /*
                 getNymbox            -- client is NOT sending hash, server is
                 NOT rejecting bad hashes, server IS SENDING HASH in the
                 @getNymbox reply
                 getRequest            -- client is NOT sending hash, server is
                 NOT rejecting bad hashes, server IS SENDING HASH in the
                 @getRequest reply

                 processNymbox        -- client is SENDING HASH, server is
                 REJECTING BAD HASHES, server is SENDING HASH in the
                 @processNymbox  reply
                 notarizeTransactions    -- client is SENDING HASH, server is
                 REJECTING BAD HASHES, server is SENDING HASH in the
                 @notarizeTransactions  reply
                 processInbox         -- client is SENDING HASH, server is
                 REJECTING BAD HASHES, server is SENDING HASH in the
                 @processInbox  reply
                 triggerClause         -- client is SENDING HASH, server is
                 REJECTING BAD HASHES, server is SENDING HASH in the
                 @triggerClause reply

                 getTransactionNum     -- client is SENDING HASH, server is
                 REJECTING BAD HASHES, server is SENDING HASH in the
                 @getTransactionNum reply

                 Already covered in NotarizeTransaction:
                    transfer, withdrawal, deposit, marketOffer, paymentPlan,
                 smartContract, cancelCronItem, exchangeBasket
                 */

                if (pThisMsg->m_ascPayload.Exists() &&
                    (pThisMsg->m_strCommand.Compare("processNymbox") ||
                     pThisMsg->m_strCommand.Compare("processInbox") ||
                     pThisMsg->m_strCommand.Compare("notarizeTransactions") ||
                     pThisMsg->m_strCommand.Compare("triggerClause"))) {
                    //
                    // If we are here in the first place (i.e. after @getNymbox
                    // just removed
                    // all the messages in this sent buffer that already had a
                    // reply sitting
                    // in the nymbox) therefore we KNOW any messages in here
                    // never got a reply
                    // from the server

                    const bool bReplyWasSuccess =
                        false; // If the msg had been a success, the reply
                               // (whether transaction within succeeded or
                               // failed) would have been dropped into my
                               // Nymbox, and thus removed from this "sent
                               // buffer" in @getNymbox.
                    const bool bReplyWasFailure =
                        true; // If the msg had been an explicit failure, the
                              // reply (without the transaction inside of it
                              // even having a chance to succeed or fail) would
                              // definitely NOT have been dropped into my
                              // Nymbox, and thus removed from this "sent
                              // buffer" in @getNymbox. However, IN THIS ONE
                              // CASE, since we DID just download the Nymbox and
                              // verify there ARE NO REPLIES for this request
                              // number (before calling this function), and
                              // since a dropped message is basically identical
                              // to a rejected message, since in either case,
                              // the transaction itself never even had a chance
                              // to run, we are able to now harvest the message
                              // AS IF the server HAD explicitly rejected the
                              // message. This is why I pass true here, where
                              // anywhere else in the code I would always pass
                              // false unless I had explicitly received a
                              // failure from the server. This place in the
                              // code, where we are now, is the failsafe
                              // endpoint for missed/dropped messages! IF they
                              // STILL haven't been found by this point, they
                              // are cleaned up as if the message was explicitly
                              // rejected by the server before the transaction
                              // even had a chance to run.

                    const bool bTransactionWasSuccess =
                        false; // Per above, since "the transaction never had a
                               // chance to run" then it could NOT have been an
                               // explicit success.
                    const bool bTransactionWasFailure =
                        false; // Per above, since "the transaction never had a
                               // chance to run" then it could NOT have been an
                               // explicit failure.

                    pThisMsg->HarvestTransactionNumbers(
                        *pNym, // Actually it's pNym who is "harvesting" the
                               // numbers in this call.   <========= HARVEST
                        *pbHarvestingForRetry, bReplyWasSuccess,
                        bReplyWasFailure, bTransactionWasSuccess,
                        bTransactionWasFailure);
                } // if there's a transaction to be harvested inside this
                  // message.
            }     // if pNym !nullptr

            auto temp_it = it;
            ++temp_it;
            messagesMap_.erase(it);
            it = temp_it; // here's where the iterator gets incremented (during
                          // the erase, basically.)

            delete pThisMsg; // <============ DELETE
            pThisMsg = nullptr;

            if (nullptr != pstrNymID && nullptr != pstrServerID) {
                OTString strFolder, strFile;
                strFolder.Format("%s%s%s%s%s%s%s", OTFolders::Nym().Get(),
                                 OTLog::PathSeparator(), pstrServerID->Get(),
                                 OTLog::PathSeparator(), "sent",
                                 /*todo hardcoding*/ OTLog::PathSeparator(),
                                 pstrNymID->Get());
                strFile.Format("%lld.msg", lRequestNum);

                OTNumList theNumList;
                std::string str_data_filename("sent.dat"); // todo hardcoding.
                if (OTDB::Exists(strFolder.Get(), str_data_filename)) {
                    OTString strNumList(OTDB::QueryPlainString(
                        strFolder.Get(), str_data_filename));
                    if (strNumList.Exists()) theNumList.Add(strNumList);
                    theNumList.Remove(lRequestNum); // Clear (this function)
                                                    // loops and removes them.
                                                    // (Here's the one being
                                                    // removed this iteration.)
                }
                else // it doesn't exist on disk, so let's just create it from
                       // the list we have in RAM so we can store it to disk.
                { // NOTE: this may be unnecessary since we are "clear"ing them
                    // all anyway. But that just means we can remove this
                    // block during optimization. Todo optimize.
                    // Since we create the NumList based on messagesMap_, and
                    // since the message for this iteration was already removed
                    // above, we don't need to remove anything at this point, we
                    // just create the NumList to contain the same numbers as
                    // are
                    // in messagesMap_.
                    //
                    it = messagesMap_.begin();
                    while (it != messagesMap_.end()) {

                        const int64_t& lTempReqNum = it->first;

                        OTMessage* pMsg = it->second;
                        OT_ASSERT(nullptr != pMsg);

                        //
                        // If a server ID was passed in, but doesn't match the
                        // server ID on this message,
                        // Then skip this one. (Same with the NymID.)
                        //
                        if (!pstrServerID->Compare(pMsg->m_strServerID) ||
                            !pstrNymID->Compare(pMsg->m_strNymID)) {
                            ++it;
                            continue;
                        }
                        else {
                            theNumList.Add(lTempReqNum);
                        }
                        ++it;
                    }
                } // else

                // By this point, theNumList has either been loaded from local
                // storage and had the number removed,
                // or it wasn't in local storage and thus we created it and
                // added all the numbers to it from RAM (not
                // including the one being erased, since it was already removed
                // from the RAM list, above.) So either
                // way, the number being removed is now ABSENT from theNumList.
                //
                // Therefore nothing left to do here, but save it back again!
                //
                OTString strOutput;
                theNumList.Output(strOutput);
                if (!OTDB::StorePlainString(strOutput.Get(), strFolder.Get(),
                                            str_data_filename)) // todo
                                                                // hardcoding.
                {
                    otErr << "OTMessageOutbuffer::Clear: Error: failed writing "
                             "list of request numbers to storage.\n";
                }

                // Make sure any messages being erased here, are also erased
                // from local storage.
                // Now that we've updated the numlist in local storage, let's
                // erase the sent message itself...
                //
                OTMessage* pMsg = new OTMessage;
                OT_ASSERT(nullptr != pMsg);
                std::unique_ptr<OTMessage> theMsgAngel(pMsg);

                if (OTDB::Exists(strFolder.Get(), strFile.Get()) &&
                    pMsg->LoadContract(strFolder.Get(), strFile.Get())) {
                    OTDB::EraseValueByKey(strFolder.Get(), strFile.Get());
                }
            }
        }
    }
}

OTMessage * opentxs::OTMessageOutbuffer::GetSentMessage	(	const int64_t &	requestNum,
		const OTString &	serverId,
		const OTString &	nymId
	)

Definition at line 313 of file OTMessageOutbuffer.cpp.

{
    auto it = messagesMap_.begin();

    for (; it != messagesMap_.end(); ++it) {

        const int64_t& lTempReqNum = it->first;

        if (lTempReqNum != lRequestNum) {
            continue;
        }

        OTMessage* pMsg = it->second;
        OT_ASSERT(nullptr != pMsg);

        //
        // If a server ID was passed in, but doesn't match the server ID on this
        // message,
        // Then skip this one. (Same with the NymID.)
        if (!strServerID.Compare(pMsg->m_strServerID) ||
            !strNymID.Compare(pMsg->m_strNymID)) {
            continue;
        }
        else {
            return pMsg;
        }
    }

    // Didn't find it? Okay let's load it from local storage, if it's there...
    //
    OTString strFolder, strFile;
    strFolder.Format(
        "%s%s%s%s%s%s%s", OTFolders::Nym().Get(), OTLog::PathSeparator(),
        strServerID.Get(), OTLog::PathSeparator(), "sent",
        /*todo hardcoding*/ OTLog::PathSeparator(), strNymID.Get());
    strFile.Format("%lld.msg", lRequestNum);

    // Check the existing list, if it exists.
    //
    OTNumList theNumList;
    std::string str_data_filename("sent.dat");
    if (OTDB::Exists(strFolder.Get(), str_data_filename)) // todo hardcoding.
    {
        OTString strNumList(
            OTDB::QueryPlainString(strFolder.Get(), str_data_filename));

        if (strNumList.Exists()) theNumList.Add(strNumList);

        if (theNumList.Verify(lRequestNum)) {
            // Even if the outgoing message was stored, we still act like it
            // "doesn't exist" if it doesn't appear on the official list.
            // The list is what matters -- the message is just the contents
            // referenced
            // by that list.

            OTMessage* pMsg = new OTMessage;
            OT_ASSERT(nullptr != pMsg);
            std::unique_ptr<OTMessage> theMsgAngel(pMsg);

            if (OTDB::Exists(strFolder.Get(), strFile.Get()) &&
                pMsg->LoadContract(strFolder.Get(), strFile.Get())) {
                // Since we had to load it from local storage, let's add it to
                // the list in RAM.
                //
                messagesMap_.insert(std::pair<int64_t, OTMessage*>(
                    lRequestNum, theMsgAngel.release()));
                return pMsg;
            }
        }
    }

    // STILL didn't find it? (Failure.)
    //
    return nullptr;
}

OTMessage * opentxs::OTMessageOutbuffer::GetSentMessage

(

const OTTransaction &

transaction

)

Definition at line 821 of file OTMessageOutbuffer.cpp.

{
    const int64_t& lRequestNum = theTransaction.GetRequestNum();
    const OTString strServerID(theTransaction.GetPurportedServerID());
    const OTString strNymID(theTransaction.GetUserID());

    return GetSentMessage(lRequestNum, strServerID, strNymID);
}

bool opentxs::OTMessageOutbuffer::RemoveSentMessage	(	const int64_t &	requestNum,
		const OTString &	serverId,
		const OTString &	nymId
	)

Definition at line 692 of file OTMessageOutbuffer.cpp.

{
    OTString strFolder, strFile;
    strFolder.Format(
        "%s%s%s%s%s%s%s", OTFolders::Nym().Get(), OTLog::PathSeparator(),
        strServerID.Get(), OTLog::PathSeparator(), "sent",
        /*todo hardcoding*/ OTLog::PathSeparator(), strNymID.Get());
    strFile.Format("%lld.msg", lRequestNum);

    auto it = messagesMap_.begin();

    bool bReturnValue = false;

    while (it != messagesMap_.end()) {

        const int64_t& lTempReqNum = it->first;

        if (lTempReqNum != lRequestNum) {
            ++it;
            continue;
        }

        OTMessage* pMsg = it->second;
        OT_ASSERT(nullptr != pMsg);

        //
        // If a server ID was passed in, but doesn't match the server ID on this
        // message,
        // Then skip this one. (Same with the NymID.)
        if (!strServerID.Compare(pMsg->m_strServerID) ||
            !strNymID.Compare(pMsg->m_strNymID)) {
            ++it;
            continue;
        }
        else {
            delete pMsg;
            pMsg = nullptr;

            auto temp_it = it;
            ++temp_it;
            messagesMap_.erase(it);
            it = temp_it; // here's where it gets incremented. (During the
                          // erase, basically.)

            bReturnValue = true;
            break;
        }
    }

    // Whether we found it in RAM or not, let's make sure to delete it from
    // local storage, if it's there... (Since there's a list there we have to
    // update,
    // anyway.)
    // We keep a list of the request numbers, so let's load it up, remove the
    // number
    // from that list, and then save it again.

    OTNumList theNumList;
    std::string str_data_filename("sent.dat"); // todo hardcoding.
    if (OTDB::Exists(strFolder.Get(), str_data_filename)) {
        OTString strNumList(
            OTDB::QueryPlainString(strFolder.Get(), str_data_filename));
        if (strNumList.Exists()) theNumList.Add(strNumList);
        theNumList.Remove(lRequestNum);
    }
    else // it doesn't exist on disk, so let's just create it from the list we
           // have in RAM so we can store it to disk.
    {
        it = messagesMap_.begin();
        while (it != messagesMap_.end()) {

            const int64_t& lTempReqNum = it->first;

            OTMessage* pMsg = it->second;
            OT_ASSERT(nullptr != pMsg);

            //
            // If a server ID was passed in, but doesn't match the server ID on
            // this message,
            // Then skip this one. (Same with the NymID.)
            //
            if (!strServerID.Compare(pMsg->m_strServerID) ||
                !strNymID.Compare(pMsg->m_strNymID)) {
                ++it;
                continue;
            }
            else {
                theNumList.Add(lTempReqNum);
            }
            ++it;
        }
    } // else

    // By this point, theNumList has either been loaded from local storage and
    // had the number removed,
    // or it wasn't in local storage and thus we created it and added all the
    // numbers to it from RAM (not
    // including the one being erased, since it was already removed from the RAM
    // list, above.) So either
    // way, the number being removed is now ABSENT from theNumList.
    //
    // Therefore nothing left to do here, but save it back again!
    //
    OTString strOutput;
    theNumList.Output(strOutput);
    if (!OTDB::StorePlainString(strOutput.Get(), strFolder.Get(),
                                str_data_filename)) {
        otErr << "OTMessageOutbuffer::RemoveSentMessage: Error: failed writing "
                 "list of request numbers to storage.\n";
    }

    // Now that we've updated the numlist in local storage, let's
    // erase the sent message itself...
    //
    OTMessage* pMsg = new OTMessage;
    OT_ASSERT(nullptr != pMsg);
    std::unique_ptr<OTMessage> theMsgAngel(pMsg);

    if (OTDB::Exists(strFolder.Get(), strFile.Get()) &&
        pMsg->LoadContract(strFolder.Get(), strFile.Get())) {
        OTDB::EraseValueByKey(strFolder.Get(), strFile.Get());
        return true;
    }

    return bReturnValue;
}

bool opentxs::OTMessageOutbuffer::RemoveSentMessage

(

const OTTransaction &

transaction

)

Definition at line 833 of file OTMessageOutbuffer.cpp.

{
    const int64_t& lRequestNum = theTransaction.GetRequestNum();
    const OTString strServerID(theTransaction.GetPurportedServerID());
    const OTString strNymID(theTransaction.GetUserID());

    return RemoveSentMessage(lRequestNum, strServerID, strNymID);
}

---

The documentation for this class was generated from the following files:

• /usr/local/src/opentxs/include/opentxs/client/OTMessageOutbuffer.hpp
• /usr/local/src/opentxs/src/client/OTMessageOutbuffer.cpp