opentxs::UserCommandProcessor Class Reference

#include <UserCommandProcessor.hpp>

Public Member Functions
	UserCommandProcessor (OTServer *server)
bool	ProcessUserCommand (OTMessage &msgIn, OTMessage &msgOut, ClientConnection *connection, OTPseudonym *nym)

Detailed Description

Definition at line 147 of file UserCommandProcessor.hpp.

Constructor & Destructor Documentation

opentxs::UserCommandProcessor::UserCommandProcessor

(

OTServer *

server

)

Definition at line 158 of file UserCommandProcessor.cpp.

    : server_(server)
{
}

Member Function Documentation

bool opentxs::UserCommandProcessor::ProcessUserCommand	(	OTMessage &	msgIn,
		OTMessage &	msgOut,
		ClientConnection *	connection,
		OTPseudonym *	nym
	)

                         ((false ==

bLoadedSignedNymfile) && (false == bLoadedPublicKey)) // It's like this now so unregistered Nyms

Definition at line 166 of file UserCommandProcessor.cpp.

{
    msgOut.m_strRequestNum.Set(theMessage.m_strRequestNum);

    if (ServerSettings::__admin_server_locked &&
        ((ServerSettings::GetOverrideNymID().size() <=
          0) || // AND (there's no Override Nym ID listed --OR-- the Override
                // Nym ID doesn't
         (0 !=
          ServerSettings::GetOverrideNymID().compare(
              (theMessage.m_strNymID.Get()))))) // match the Nym's ID who
                                                // sent this message)
    {
        OTLog::vOutput(
            0, "UserCommandProcessor::ProcessUserCommand: Nym %s: failed "
               "attempt to message the server, while server is in "
               "**LOCK DOWN MODE**.\n",
            theMessage.m_strNymID.Get());
        return false;
    }

    // Validate the server ID, to keep users from intercepting a valid requst
    // and sending it to the wrong server.
    if (!(server_->m_strServerID == theMessage.m_strServerID)) {
        OTLog::Error("UserCommandProcessor::ProcessUserCommand: Invalid server "
                     "ID sent in "
                     "command request.\n");
        return false;
    }
    else {
        OTLog::Output(4, "Received valid Server ID with command request.\n");
    }
    // NYM WAS PASSED IN
    //
    OTPseudonym theNym(theMessage.m_strNymID);

    if (nullptr == pNym)
        pNym = &theNym; // If one wasn't passed in, we'll use the one
                        // constructed here. (One line up.)
    else if (!pNym->CompareID(theNym)) {
        OTString strTempNymID;
        pNym->GetIdentifier(strTempNymID);
        OTLog::vError(
            "UserCommandProcessor::ProcessUserCommand: NymID on the optional "
            "Nym passed in "
            "(%s) "
            "does NOT match the NymID on theMessage (%s). (Returning false.)\n",
            strTempNymID.Get(), theMessage.m_strNymID.Get());
        return false;
    }
    // NYM IS ACTUALLY SERVER

    // For special cases where the Nym sending the transaction has the same
    // public key as
    // the server itself. (IE it IS the server Nym, then we'd want to use the
    // already-loaded
    // server nym object instead of loading a fresh one, so the two don't
    // overwrite each other.)
    //
    const bool bNymIsServerNym =
        (server_->m_strServerUserID.Compare(theMessage.m_strNymID) ? true
                                                                   : false);
    //    OTPseudonym * pNym = &theNym; // this is now done higher up in this
    // function.

    if (bNymIsServerNym) pNym = &server_->m_nymServer;

    // This command is special because the User sent his public key, not just
    // his ID.
    // We have to verify the two together.
    //
    // At this point the user doesn't even have an account, so there is no
    // public key
    // to look up from the database.
    //
    // If the ServerID in the reply matches the ID calculated from the Server
    // Contract,
    // that means the user, without asking for the server's public key, can just
    // extract
    // the public key from the contract from which the serverID was first
    // calculated. (The
    // ID is a hash of the contract.)
    //
    // In other words, the user reads a contract. It's signed. The signature is
    // verified
    // by a public key that is embedded in the contract. If the server, a URL
    // also embedded in
    // the contract, acknowledges the ServerID, then the user can encrypt
    // everything to the
    // public key in the contract, without asking the server for a copy of that
    // key.
    //
    // Only the private key who signed that contract will be able to read the
    // communications from
    // the user.
    //
    // I definitely have to build in an option for x509 certs to be used in lieu
    // of public keys.
    // Otherwise the key is not ever revokable -- yet it's in a contract!  What
    // is the issuer supposed
    // to do if that key is stolen? Make a public announcement?
    //
    // UPDATE ONE-LINE NOTE: THE TRUE SOLUTION TO THIS WHOLE ISSUE IS:   ***
    // NAMECOIN ***
    // (Now continuing back to my old comments from 18 months ago...)
    //
    // In such a case, the issuer would have to put a "check this URL to make
    // sure contract still good"
    // variable into the contract so that the users have the chance to make sure
    // the contract is still
    // good and the contract's private key hasn't been stolen. Well guess what?
    // That's what x509 does.
    // Therefore the appropriate solution is for the server to support x509s,
    // and to look up the authority
    // and verify certs, so that users have recourse in the event their private
    // key is stolen. (They can
    // just use their Cert to issue a new public key, which the transaction
    // server would be smart enough
    // to use, once the certificate authority signs off on it. (Since the user
    // uses an x509 from a
    // specific authority, then I can trust that whatever that authority says,
    // that user wanted it to say.)
    // Without knowing the authority itself, I can now trust it because the user
    // has asked me to trust it.
    // Fair enough!
    //
    // Similarly a user should be able to use his x509 Cert instead of his
    // public key, and the server
    // should verify that cert whenever it's used to make sure it's up to date.
    // This takes the
    // problem off of the user's hands by way of a trusted authority.
    //
    // In fact this transaction server is really just a transaction VERIFIER.
    // It's just another form
    // of trusted 3rd party. Just like Verisign is an authority who ceritifies
    // an identity, so this
    // server is an authority who certifies a transaction. It's like a
    // timestamping server. In fact
    // it should have timestamping built in as one of the functions.
    //
    // Transactions do not actually occur on the server, per se. They occur
    // between the USERS.
    // All the server does it certify that the numbers are correct. It's like
    // accounting software.
    // Ultimately the users are the ones making a transaction, and they are the
    // ones who are
    // responsible to back up their promises in real life and potentially in
    // court. All the software
    // does is CERTIFY that the users DID make certain agreements at certain
    // times, and digitally sign
    // those certifications.
    //
    // Thus, this server is very similar to Verisign. It is a trusted 3rd party
    // who users can trust
    // to authenticate their transactions. Instead of authenticating
    // certifications like Verisign does,
    // it authenticates transactions.
    //
    // UPDATE: May not want x509's after all, since it provides an opening for
    // governments to
    // serve warrants on the authority site and switch certs whenever they want
    // to (BAD THING!)
    //
    OTString strMsgNymID;
    pNym->GetIdentifier(strMsgNymID);

    if (theMessage.m_strCommand.Compare("checkServerID")) {
        OTLog::vOutput(0,
                       "\n==> Received a checkServerID message. Nym: %s ...\n",
                       strMsgNymID.Get());
        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_check_server_id);
        std::unique_ptr<OTAsymmetricKey> pNymAuthentKey(
            OTAsymmetricKey::KeyFactory());
        std::unique_ptr<OTAsymmetricKey> pNymEncryptKey(
            OTAsymmetricKey::KeyFactory());
        OT_ASSERT(nullptr != pNymAuthentKey);
        OT_ASSERT(nullptr != pNymEncryptKey);
        OTAsymmetricKey& nymAuthentKey = *pNymAuthentKey;
        OTAsymmetricKey& nymEncryptionKey = *pNymEncryptKey;
        const bool bIfNymPublicKey =
            (nymAuthentKey.SetPublicKey(theMessage.m_strNymPublicKey,
                                        true /*bEscaped*/) &&
             nymEncryptionKey.SetPublicKey(theMessage.m_strNymID2,
                                           true /*bEscaped*/));

        if (bIfNymPublicKey) {
            if (theMessage.VerifyWithKey(nymAuthentKey)) // Not all contracts
                                                         // are signed with the
                                                         // authentication key,
                                                         // but messages are.
            {
                OTLog::Output(
                    3, "Signature verified! The message WAS signed by "
                       "the Private Authentication Key inside the message.\n");

                // This is only for verified Nyms, (and we're verified in here!)
                // We do this so that
                // we have the option later to encrypt the replies back to the
                // client...(using the
                // client's public key that we set here.)
                if (nullptr != pConnection)
                    pConnection->SetPublicKey(
                        theMessage.m_strNymID2); // theMessage.m_strNymID2
                                                 // contains the public
                                                 // encryption key for sending
                                                 // an encrypted reply.

                UserCmdCheckServerID(*pNym, theMessage, msgOut);
                return true;
            }
            else {
                OTLog::Output(
                    0, "checkServerID: Signature verification failed!\n");
                return false;
            }
        }
        else {
            OTLog::Error("Failure reading Nym's signing and/or encryption keys "
                         "from message.\n");
            return false;
        }
    }

    // The below block is now COMPLETE. (For credentials new system.)
    //
    // Next, make sure the client side is properly forming the new version of
    // this message,
    // and make sure it creates credentials when necessary, if they don't
    // already exist
    // (Since this new server version ONLY accepts credentials, and not
    // old-style public keys.)
    //
    // This command is also special because again, the User sent his public key,
    // not just his ID.
    // We have to verify the two together.
    // UPDATE: now the Nym sends not a public key, but a full set of credentials
    // along with
    // a list of credential IDs. You load the list of credential IDs as if you
    // are loading the Nym
    // from a string. (It's like a nym that only contains the credential parts.)
    // Then in the process
    // of loading the Nym, it will load the credentials from the mapOfStrings.
    //
    else if (theMessage.m_strCommand.Compare("createUserAccount")) {
        OTLog::vOutput(
            0, "\n==> Received a createUserAccount message. Nym: %s ...\n",
            strMsgNymID.Get());
        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_create_user_acct);
        if (bNymIsServerNym) {
            OTLog::Output(0,
                          "**** Sorry, the server Nym is forbidden from using "
                          "the createUserAccount message as a client. "
                          "PLEASE REMOVE THAT NYM FROM YOUR WALLET!! Create a "
                          "fresh Nym to use. ***\n");
            return false;
        }
        // First try to get Credentials, if there are any.
        //
        OTASCIIArmor& ascArmor = theMessage.m_ascPayload;   // credentialList
                                                            // (New style!
                                                            // Credentials.)
        OTASCIIArmor& ascArmor2 = theMessage.m_ascPayload2; // credentials
        const bool bHasCredentials = (ascArmor.Exists() && ascArmor2.Exists());
        if (bHasCredentials) // New style of doing things, for Nym keys.
                             // Credentials!
        {
            // credentialList
            //
            OTString strCredentialList(ascArmor);

            if (strCredentialList.Exists()) {
                std::unique_ptr<OTDB::Storable> pStorable(OTDB::DecodeObject(
                    OTDB::STORED_OBJ_STRING_MAP, ascArmor2.Get()));
                OTDB::StringMap* pMap =
                    dynamic_cast<OTDB::StringMap*>(pStorable.get());
                if (nullptr == pMap)
                    OTLog::vOutput(0, "%s: @createUserAccount: Failed decoding "
                                      "StringMap object.\n",
                                   __FUNCTION__);
                else {
                    auto& theMap = pMap->the_map;
                    // NOTE: This action may very well be a malicious attacker
                    // saving a false
                    // credential list and a false set of credentials under a
                    // certain Nym ID!
                    // However, a Nym is always verified after loading, before
                    // being used for
                    // anything. (AND MUST BE.) And that includes before being
                    // saved to disk.
                    //
                    // DILEMMA at this point was, I don't want to save the
                    // credentials into the
                    // actual folder locations BEFORE they have been verified...
                    // SO I had to add "LoadFromString" functions to
                    // OTCredential (which I have done.)
                    // So now I should be able to continue here, load the
                    // credentials up from string,
                    // verify them, and if verified, THEN save them to disk...
                    // OTPseudonym::LoadFromString now allows you to load
                    // credentials from the map passed
                    // in (from the message) versus just reading them from local
                    // storage.
                    //
                    if (false ==
                        pNym->LoadFromString(strCredentialList, &theMap)) {
                        OTLog::vError(
                            "%s: @createUserAccount: Failure loading nym %s "
                            "from credential string.\n",
                            __FUNCTION__, theMessage.m_strNymID.Get());
                    }
                    // Now that the Nym has been loaded up from the message
                    // parameters,
                    // including the list of credential IDs, and the map
                    // containing the
                    // credentials themselves, let's try to Verify the
                    // pseudonym. If we
                    // verify, then we're safe to save the credentials to
                    // storage.
                    //
                    else if (!pNym->VerifyPseudonym()) {
                        OTLog::vError(
                            "%s: @createUserAccount: Loaded nym %s "
                            "from credentials, but then it failed verifying.\n",
                            __FUNCTION__, theMessage.m_strNymID.Get());
                    }
                    else // Okay, we loaded the Nym up from the credentials in
                           // the message, AND
                    {      // verified the Nym (including the credentials.)
                        // So let's save it to local storage...
                        //

                        OTLog::Output(3, "Pseudonym verified!\n");
                        // Okay, now that the Nym is verified, let's verify the
                        // message itself...
                        //
                        if (false ==
                            theMessage.VerifySignature(*pNym)) // FYI, OTMessage
                                                               // overrides
                        // VerifySignature with
                        // VerifySigAuthent.
                        { // (Because we use authentication keys, not signing
                            // keys, for messages.)
                            OTLog::Output(0, "@createUserAccount: "
                                             "Authentication signature -- "
                                             "verification failed!\n");
                            return false;
                        }
                        else {
                            OTLog::Output(
                                3,
                                "Signature verified! The message WAS signed by "
                                "the Nym\'s private authentication key.\n");
                            // SAVE the credentials to local storage, now that
                            // things are verified.
                            //
                            std::string str_nym_id =
                                theMessage.m_strNymID.Get();
                            OTString strFilename;
                            strFilename.Format("%s.cred", str_nym_id.c_str());

                            bool bStoredList = false;
                            OTString strOutput;

                            if (ascArmor.Exists() &&
                                ascArmor.WriteArmoredString(
                                    strOutput,
                                    "CREDENTIAL LIST") && // bEscaped=false by
                                                          // default.
                                strOutput.Exists())
                                bStoredList = OTDB::StorePlainString(
                                    strOutput.Get(), OTFolders::Pubcred().Get(),
                                    strFilename.Get());
                            if (!bStoredList)
                                OTLog::vError("%s: @createUserAccount: Failed "
                                              "trying to armor or store: %s\n",
                                              __FUNCTION__, strFilename.Get());
                            else // IF the list saved, then we save the
                                 // credentials themselves...
                            {
                                OTLog::vOutput(1, "@createUserAccount: Success "
                                                  "saving public credential "
                                                  "list for Nym: %s\n",
                                               str_nym_id.c_str());
                                for (auto& it : theMap) {
                                    std::string str_cred_id = it.first;
                                    OTString strCredential(it.second);
                                    bool bStoredCredential = false;
                                    strOutput.Release();
                                    OTASCIIArmor ascLoopArmor(strCredential);
                                    if (ascLoopArmor.Exists() &&
                                        ascLoopArmor.WriteArmoredString(
                                            strOutput,
                                            "CREDENTIAL") && // bEscaped=false
                                                             // by default.
                                        strOutput.Exists())
                                        bStoredCredential =
                                            OTDB::StorePlainString(
                                                strOutput.Get(),
                                                OTFolders::Pubcred().Get(),
                                                str_nym_id, str_cred_id);
                                    if (!bStoredCredential)
                                        OTLog::vError(
                                            "%s: @createUserAccount: Failed "
                                            "trying to store credential %s for "
                                            "nym %s.\n",
                                            __FUNCTION__, str_cred_id.c_str(),
                                            str_nym_id.c_str());
                                    else
                                        OTLog::vOutput(0, "@createUserAccount: "
                                                          "Success saving "
                                                          "public credential "
                                                          "ID: %s\n",
                                                       str_cred_id.c_str());
                                }
                            } // else (bStoredList)
                            // Make sure we are encrypting the message we send
                            // back, if possible.
                            //
                            OTString strPublicEncrKey, strPublicSignKey;
                            OTAsymmetricKey& thePublicEncrKey =
                                (OTAsymmetricKey&)
                                pNym->GetPublicEncrKey(); // todo cast
                            OTAsymmetricKey& thePublicSignKey =
                                (OTAsymmetricKey&)
                                pNym->GetPublicSignKey(); // todo cast

                            thePublicEncrKey.GetPublicKey(
                                strPublicEncrKey,
                                false); // bEscaped=true by default
                            thePublicSignKey.GetPublicKey(
                                strPublicSignKey,
                                false); // bEscaped=true by default

                            // We also (for now) set the Nym's keypair (which is
                            // being phased out entirely,
                            // and being replaced with credentials.)
                            //
                            if (strPublicSignKey.Exists())
                                pNym->SetPublicKey(
                                    strPublicSignKey,
                                    false); // bEscaped=true by default

                            // This is only for verified Nyms, (and we're
                            // verified in here!) We do this so that
                            // we have the option later to encrypt the replies
                            // back to the client...(using the
                            // client's public key that we set here.)
                            if (strPublicEncrKey.Exists() &&
                                (nullptr != pConnection))
                                pConnection->SetPublicKey(thePublicEncrKey);
                            // Look up the NymID and see if it's already a valid
                            // user account.
                            //
                            // If it is, then we can't very well create it
                            // twice, can we?
                            //
                            // UPDATE: Actually we should, in such cases, just
                            // return true with
                            // a copy of the Nymfile. Helps prevent sync errors,
                            // and gives people
                            // a way to grab the server's copy of their nymfile,
                            // if they need it.
                            //
                            OTLog::Output(
                                0, "Verifying account doesn't already exist... "
                                   "(IGNORE ANY ERRORS, IMMEDIATELY BELOW, "
                                   "ABOUT FAILURE OPENING FILES)\n");

                            // Prepare to send success or failure back to user.
                            // (1) set up member variables
                            msgOut.m_strCommand =
                                "@createUserAccount"; // reply to
                                                      // createUserAccount
                            msgOut.m_strNymID = theMessage.m_strNymID; // UserID
                            msgOut.m_strServerID =
                                server_->m_strServerID; // ServerID, a hash of
                                                        // the server
                                                        // contract.
                            msgOut.m_bSuccess = false;

                            // already done, top of this function.
                            //                          msgOut.m_strRequestNum.Set(theMessage.m_strRequestNum);
                            // // to prevent replay attacks.

                            // We send the user's message back to him,
                            // ascii-armored,
                            // as part of our response.
                            OTString tempInMessage;
                            theMessage.SaveContractRaw(tempInMessage);
                            msgOut.m_ascInReferenceTo.SetString(tempInMessage);

                            bool bLoadedSignedNymfile =
                                pNym->LoadSignedNymfile(server_->m_nymServer);

                            // He ALREADY exists. We'll set success to true, and
                            // send him a copy of his own nymfile.
                            // (Signature is verified already anyway, by this
                            // point.)
                            //
                            if (bLoadedSignedNymfile &&
                                (false == pNym->IsMarkedForDeletion())) {
                                OTLog::vOutput(
                                    0,
                                    "(Allowed in order to prevent sync issues) "
                                    "==> User is registering nym that already "
                                    "exists: %s\n",
                                    theMessage.m_strNymID.Get());

                                OTString strNymContents;
                                pNym->SavePseudonym(strNymContents);
                                OTIdentifier theNewNymID,
                                    SERVER_ID(server_->m_strServerID);
                                pNym->GetIdentifier(theNewNymID);
                                OTLedger theNymbox(theNewNymID, theNewNymID,
                                                   SERVER_ID);
                                bool bSuccessLoadingNymbox =
                                    theNymbox.LoadNymbox();

                                if (true == bSuccessLoadingNymbox)
                                    bSuccessLoadingNymbox =
                                        (theNymbox.VerifyContractID() &&
                                         theNymbox.VerifyAccount(
                                             server_->m_nymServer));
                                //                                    bSuccessLoadingNymbox
                                // =
                                // (theNymbox.VerifyAccount(server_->m_nymServer));
                                // //
                                // (No need here to load all the Box Receipts)
                                else {
                                    bSuccessLoadingNymbox =
                                        theNymbox.GenerateLedger(
                                            theNewNymID, SERVER_ID,
                                            OTLedger::nymbox,
                                            true); // bGenerateFile=true

                                    if (bSuccessLoadingNymbox) {
                                        bSuccessLoadingNymbox =
                                            theNymbox.SignContract(
                                                server_->m_nymServer);

                                        if (bSuccessLoadingNymbox) {
                                            bSuccessLoadingNymbox =
                                                theNymbox.SaveContract();

                                            if (bSuccessLoadingNymbox)
                                                bSuccessLoadingNymbox =
                                                    theNymbox.SaveNymbox();
                                        }
                                    }
                                }
                                // by this point, the nymbox DEFINITELY exists
                                // -- or not. (generation might have failed, or
                                // verification.)
                                //
                                if (!bSuccessLoadingNymbox) {
                                    OTLog::vError("Error during user account "
                                                  "re-registration. Failed "
                                                  "verifying or generating "
                                                  "nymbox for user: %s\n",
                                                  theMessage.m_strNymID.Get());
                                }
                                msgOut.m_ascPayload.SetString(strNymContents);
                                msgOut.m_bSuccess = bSuccessLoadingNymbox;
                                msgOut.SignContract(server_->m_nymServer);
                                msgOut.SaveContract();
                                return true;
                            }
                            else
                            //                               ((pNym->IsMarkedForDeletion()
                            // &&  (true == bLoadedPublicKey)) ||  // We
                            // allow people to resurrect deleted Nyms.
                            //                                (false ==
                            // bLoadedPublicKey))
                            // // can still buy usage credits.
                            {
                                if (pNym->IsMarkedForDeletion())
                                    pNym->MarkAsUndeleted();

                                // Good -- this means the account doesn't
                                // already exist.
                                // Let's create it.

                                msgOut.m_bSuccess = theMessage.SaveContract(
                                    OTFolders::UserAcct().Get(),
                                    theMessage.m_strNymID.Get());

                                // First we save the createUserAccount message
                                // in the accounts folder...
                                if (msgOut.m_bSuccess) {
                                    OTLog::Output(0, "Success saving new user "
                                                     "account verification "
                                                     "file.\n");

                                    OTIdentifier theNewNymID,
                                        SERVER_ID(server_->m_strServerID);
                                    pNym->GetIdentifier(theNewNymID);
                                    OTLedger theNymbox(theNewNymID, theNewNymID,
                                                       SERVER_ID);
                                    bool bSuccessLoadingNymbox =
                                        theNymbox.LoadNymbox();

                                    if (true == bSuccessLoadingNymbox) // that's
                                        // strange, this
                                        // user didn't
                                        // exist... but
                                        // maybe I allow
                                        // people to drop
                                        // notes anyway,
                                        // so then the
                                        // nymbox might
                                        // already exist,
                                        // with usage
                                        // tokens and
                                        // messages
                                        // inside....
                                        bSuccessLoadingNymbox =
                                            (theNymbox.VerifyContractID() &&
                                             theNymbox.VerifyAccount(
                                                 server_->m_nymServer));
                                    //                                        bSuccessLoadingNymbox
                                    // =
                                    // (theNymbox.VerifyAccount(server_->m_nymServer));
                                    // // (No need here to load all the Box
                                    // Receipts)
                                    else {
                                        bSuccessLoadingNymbox =
                                            theNymbox.GenerateLedger(
                                                theNewNymID, SERVER_ID,
                                                OTLedger::nymbox,
                                                true); // bGenerateFile=true
                                        if (bSuccessLoadingNymbox) {
                                            bSuccessLoadingNymbox =
                                                theNymbox.SignContract(
                                                    server_->m_nymServer);
                                            if (bSuccessLoadingNymbox) {
                                                bSuccessLoadingNymbox =
                                                    theNymbox.SaveContract();

                                                if (bSuccessLoadingNymbox)
                                                    bSuccessLoadingNymbox =
                                                        theNymbox.SaveNymbox();
                                            }
                                        }
                                    }
                                    // by this point, the nymbox DEFINITELY
                                    // exists -- or not. (generation might have
                                    // failed, or verification.)

                                    if (!bSuccessLoadingNymbox) {
                                        OTLog::vError(
                                            "Error during user account "
                                            "registration. Failed verifying or "
                                            "generating nymbox for user: %s\n",
                                            theMessage.m_strNymID.Get());
                                    }
                                    // Either we loaded it up (it already
                                    // existed) or we didn't, in which case we
                                    // should
                                    // save it now (to create it.)
                                    //
                                    else if (bLoadedSignedNymfile ||
                                             pNym->SaveSignedNymfile(
                                                 server_->m_nymServer)) {
                                        OTLog::vOutput(0, "Success creating "
                                                          "new Nym. (User "
                                                          "account fully "
                                                          "created.)\n");

                                        OTString strNymContents;
                                        pNym->SavePseudonym(strNymContents);
                                        msgOut.m_ascPayload.SetString(
                                            strNymContents);
                                        msgOut.m_bSuccess = true;
                                        msgOut.SignContract(
                                            server_->m_nymServer);
                                        msgOut.SaveContract();
                                        return true;
                                    }
                                    else {
                                        msgOut.SignContract(
                                            server_->m_nymServer);
                                        msgOut.SaveContract();
                                        return true;
                                    }
                                }
                                else {
                                    OTLog::Error("Error saving new user "
                                                 "account verification "
                                                 "file.\n");
                                    msgOut.SignContract(server_->m_nymServer);
                                    msgOut.SaveContract();
                                    return true;
                                }
                            }
                            return true;
                        }
                    } // Success loading and verifying the Nym based on his
                      // credentials.
                } // Success decoding the map of credentials from the message.
            }     // credential list exists, after base64-decoding.
        }         // Has Credentials.
    }
    // Look up the NymID and see if it's a valid user account.
    //
    // If we didn't receive a public key (above)
    // Or read one from our files (below)
    // ... then we'd have no way of validating the requests.
    //
    // If it is, then we read the public key from that Pseudonym and use it to
    // verify any
    // requests bearing that NymID.
    if (!bNymIsServerNym &&
        (false == pNym->LoadPublicKey()) // && // Old style. (Deprecated, but
                                         // fine for now since it calls
                                         // LoadCredentials.)
        ) {
        OTLog::vError("Failure loading public credentials for Nym: %s\n",
                      theMessage.m_strNymID.Get());
        return false;
    }
    if (!bNymIsServerNym && pNym->IsMarkedForDeletion()) {
        OTLog::vOutput(0,
                       "(Failed) attempt by client to use a deleted Nym: %s\n",
                       theMessage.m_strNymID.Get());
        return false;
    }
    // Okay, the file was read into memory and Public Key was successfully
    // extracted!
    // Next, let's use that public key to verify (1) the NymID and (2) the
    // signature
    // on the message that we're processing.

    if (pNym->VerifyPseudonym()) {
        OTLog::Output(3, "Pseudonym verified!\n");

        // So far so good. Now let's see if the signature matches...
        if (theMessage.VerifySignature(*pNym)) {
            OTLog::Output(3, "Signature verified! The message WAS signed by "
                             "the Nym\'s private key.\n");

            // Get the public key from pNym, and set it into the connection.
            // This is only for verified Nyms, (and we're verified in here!) We
            // do this so that
            // we have the option later to encrypt the replies back to the
            // client...(using the
            // client's public key that we set here.)
            if (nullptr != pConnection)
                pConnection->SetPublicKey(pNym->GetPublicEncrKey());

            // Now we might as well load up the rest of the Nym.
            // Notice I use the || to only load the nymfile if it's NOT the
            // server Nym.
            if (bNymIsServerNym ||
                pNym->LoadSignedNymfile(server_->m_nymServer)) {
                OTLog::Output(2, "Successfully loaded Nymfile into memory.\n");

                // ENTERING THE INNER SANCTUM OF SECURITY. If the user got all
                // the way to here,
                // Then he has passed multiple levels of security, and all
                // commands below will
                // assume the Nym is secure, validated, and loaded into memory
                // for use.
                //
                // But still need to verify the Request Number for all other
                // commands except
                // Get Request Number itself...

                // Request numbers start at 100 (currently). (Since certain
                // special messages USE 1 already...
                // Such as messages that occur before requestnumbers are
                // possible, like CreateUserAccount.)
                //
                int64_t lRequestNumber = 0;

                if (false ==
                    pNym->GetCurrentRequestNum(server_->m_strServerID,
                                               lRequestNumber)) {
                    OTLog::Output(0, "Nym file request number doesn't exist. "
                                     "Apparently first-ever request to "
                                     "server--but everything checks out. "
                                     "(Shouldn't this request number have been "
                                     "created already when the NymFile was "
                                     "first created???????\n");
                    // FIRST TIME!  This account has never before made a single
                    // request to this server.
                    // The above call always succeeds unless the number just
                    // isn't there for that server.
                    // Therefore, since it's the first time, we'll create it
                    // now:
                    pNym->IncrementRequestNum(server_->m_nymServer,
                                              server_->m_strServerID);

                    // Call it again so that lRequestNumber is set to 1 also
                    if (pNym->GetCurrentRequestNum(server_->m_strServerID,
                                                   lRequestNumber)) {
                        OTLog::Output(0, "Created first request number in Nym "
                                         "file, apparently first-ever request. "
                                         "(Shouldn't this have been created "
                                         "already when the NymFile was first "
                                         "created???????\n");
                    }
                    else {
                        OTLog::Error("ERROR creating first request number in "
                                     "Nym file.\n");
                        return false;
                    }
                }

                // At this point, I now have the current request number for this
                // nym in lRequestNumber
                // Let's compare it to the one that was sent in the message...
                // (This prevents attackers
                // from repeat-sending intercepted messages to the server.)
                if (false ==
                    theMessage.m_strCommand.Compare(
                        "getRequest")) // IF it's NOT a getRequest CMD,
                                       // (therefore requires a request
                                       // number)
                {
                    if (lRequestNumber !=
                        atol(theMessage.m_strRequestNum.Get())) // AND the
                                                                // request
                                                                // number
                                                                // attached does
                                                                // not match
                                                                // what we just
                                                                // read out of
                                                                // the file...
                    {
                        OTLog::vOutput(0, "Request number sent in this message "
                                          "%ld does not match the one in the "
                                          "file! (%ld)\n",
                                       atol(theMessage.m_strRequestNum.Get()),
                                       lRequestNumber);
                        return false;
                    }
                    else // it's not a getRequest CMD, and the request number
                           // sent DOES match what we read out of the file!!
                    {
                        // USAGE CREDITS...
                        // Since (just below) we IncrementRequestNum() and
                        // therefore save the Nym,
                        // I figured it's a good spot to do our Usage Credits
                        // code, so we don't have
                        // to save twice.
                        // IF (the OT Server is in "require usage credits" mode)
                        // AND the User isn't magically FREE from
                        // having to use usage credits (-1 is a
                        // get-out-of-jail-free-card.)
                        // AND (there's no Override Nym ID listed
                        // --OR-- the Override Nym ID doesn't
                        // match the Nym's ID who sent this message
                        if (ServerSettings::__admin_usage_credits &&
                            pNym->GetUsageCredits() >= 0 &&
                            (ServerSettings::GetOverrideNymID().size() <= 0 ||
                             (0 !=
                              ServerSettings::GetOverrideNymID().compare(
                                  (theMessage.m_strNymID.Get()))))) {
                            const int64_t& lUsageCredits =
                                pNym->GetUsageCredits();

                            if (0 == lUsageCredits) // If the User has ZERO
                                                    // USAGE CREDITS LEFT. (Too
                                                    // bad, even 1 would have
                                                    // squeezed him by here.)
                            {
                                OTLog::vOutput(0, "Nym %s: ALL OUT of Usage "
                                                  "Credits, while server is in "
                                                  "**REQUIRE USAGE CREDITS "
                                                  "MODE**!\n",
                                               theMessage.m_strNymID.Get());
                                return false;
                            }

                            const int64_t lUsageFinal = (lUsageCredits - 1);
                            pNym->SetUsageCredits(lUsageFinal);
                        }

                        OTLog::vOutput(3, "Request number sent in this message "
                                          "%ld DOES match the one in the "
                                          "file!\n",
                                       lRequestNumber);

                        // At this point, it is some OTHER command (besides
                        // getRequest)
                        // AND the request number verifies, so we're going to
                        // increment
                        // the number, and let the command process.
                        pNym->IncrementRequestNum(server_->m_nymServer,
                                                  server_->m_strServerID);

                        // **INSIDE** THE INNER SANCTUM OF SECURITY. If the user
                        // got all the way to here,
                        // Then he has passed multiple levels of security, and
                        // all commands below will
                        // assume the Nym is secure, validated, and loaded into
                        // memory for use. They can
                        // also assume that the request number has been verified
                        // on this message.
                        // EVERYTHING checks out.

                        // NO RETURN HERE!!!! ON PURPOSE!!!!
                    }

                }
                else // If you entered this else, that means it IS a
                       // getRequest command
                // So we allow it to go through without verifying this step,
                // and without incrementing the counter.
                {
                    // pNym->IncrementRequestNum(server_->m_strServerID); //
                    // commented
                    // out cause this is the one case where we DON'T increment
                    // this number.
                    // We allow the user to get the number, we DON'T increment
                    // it, and now the user
                    // can send it on his next request for some other command,
                    // and it will verify
                    // properly. This prevents repeat messages.

                    // NO RETURN HERE!!!! ON PURPOSE!!!!
                }

                // At this point, we KNOW that it is EITHER a GetRequest
                // command, which doesn't require a request number,
                // OR it was some other command, but the request number they
                // sent in the command MATCHES the one that we
                // just read out of the file.

                // Therefore, we can process ALL messages below this
                // point KNOWING that the Nym is properly verified in all ways.
                // No messages need to worry about verifying the Nym, or about
                // dealing with the Request Number. It's all handled in here.

            }
            else {
                OTLog::vError("Error loading Nymfile: %s\n",
                              theMessage.m_strNymID.Get());
                return false;
            }
        }
        else {
            OTLog::Output(0, "Signature verification failed!\n");
            return false;
        }
    }
    else {
        OTLog::Output(
            0, "Pseudonym failed to verify. Hash of public key doesn't match "
               "Nym ID that was sent.\n");
        return false;
    }

    // If you made it down this far, that means the Pseudonym verifies! The
    // message is legit.
    //
    // (Server ID was good, NymID is a valid hash of User's public key, and the
    // Signature on
    // the message was signed by the user's private key.)
    //
    // Now we can process the message.
    //
    // All the commands below here, it is assumed that the user account exists
    // and is
    // referenceable via pNym. (An OTPseudonym object.)
    //
    // ALL commands below can assume the Nym is real, and that the NymID and
    // Public Key are
    // available for use -- and that they verify -- without having to check
    // again and again.

    // ACKNOWLEDGMENTS OF REPLIES ALREADY RECEIVED (FOR OPTIMIZATION.)

    // On the client side, whenever the client is DEFINITELY made aware of the
    // existence of a
    // server reply, he adds its request number to this list, which is sent
    // along with all client-side
    // requests to the server.
    // The server reads the list on the incoming client message (and it uses
    // these same functions
    // to store its own internal list.) If the # already appears on its internal
    // list, then it does
    // nothing. Otherwise, it loads up the Nymbox and removes the replyNotice,
    // and then adds the #
    // to its internal list.
    // For any numbers on the internal list but NOT on the client's list, the
    // server removes from
    // the internal list. (The client removed them when it saw the server's
    // internal list, which the
    // server sends with its replies.)
    //
    // This entire protocol, densely described, is unnecessary for OT to
    // function, but is great for
    // optimization, as it enables OT to avoid downloading all Box Receipts
    // containing replyNotices,
    // as long as the original reply was properly received when the request was
    // originally sent (which
    // is MOST of the time...)
    // Thus we can eliminate most replyNotice downloads, and likely a large % of
    // box receipt downloads
    // as well.
    //

    const OTIdentifier SERVER_ID(server_->m_strServerID);

    // The server reads the list of acknowledged replies from the incoming
    // client message...
    //
    bool bIsDirtyNym = false; // if we add any acknowledged replies to the
                              // server-side list, we will want to save (at the
                              // end.)
    std::set<int64_t> numlist_ack_reply;
    if (theMessage.m_AcknowledgedReplies.Output(
            numlist_ack_reply)) // returns false if the numlist was empty.
    {
        // Load Nymbox
        //
        OTLedger theNymbox(pNym->GetConstID(), pNym->GetConstID(), SERVER_ID);

        if (theNymbox.LoadNymbox() &&
            theNymbox.VerifySignature(server_->m_nymServer)) {
            // if we remove any replyNotices from the Nymbox, then we will want
            // to save the Nymbox (at the end.)
            bool bIsDirtyNymbox = false;

            for (auto& it : numlist_ack_reply) {
                const int64_t lRequestNum = it;
                // If the # already appears on its internal list, then it does
                // nothing. (It must have already done
                // whatever it needed to do, since it already has the number
                // recorded as acknowledged.)
                //
                // Otherwise, if the # does NOT already appear on server's
                // internal list, then it loads up the
                // Nymbox and removes the replyNotice, and then adds the # to
                // its internal list for safe-keeping.
                //
                if (false ==
                    pNym->VerifyAcknowledgedNum(server_->m_strServerID,
                                                lRequestNum)) {
                    // Verify whether a replyNotice exists in the Nymbox, with
                    // that lRequestNum
                    //
                    OTTransaction* pReplyNotice =
                        theNymbox.GetReplyNotice(lRequestNum);

                    if (nullptr != pReplyNotice) {
                        // If so, remove it...
                        //
                        const bool bDeleted =
                            pReplyNotice->DeleteBoxReceipt(theNymbox);
                        const bool bRemoved = theNymbox.RemoveTransaction(
                            pReplyNotice->GetTransactionNum()); // deletes
                        pReplyNotice = nullptr;
                        // (pReplyNotice is deleted, below this point,
                        // automatically by the above Remove call.)

                        if (!bDeleted || !bRemoved)
                            OTLog::Error(
                                "UserCommandProcessor::ProcessUserCommand: "
                                "Failed trying "
                                "to delete a box receipt, or "
                                "while removing its stub from the Nymbox.\n");

                        // ...and add lRequestNum to server's acknowledgment
                        // list. (So this can't happen twice with same #.)
                        //
                        if (pNym->AddAcknowledgedNum(
                                server_->m_strServerID,
                                lRequestNum))   // doesn't save (here).
                            bIsDirtyNym = true; // So we don't have to save EACH
                                                // iteration, but instead just
                                                // once at the bottom.

                        if (bRemoved)
                            bIsDirtyNymbox = true; // So we don't have to save
                                                   // EACH iteration, but
                                                   // instead just once at the
                                                   // bottom.
                    }
                } // If server didn't already have a record of this acknowledged
                  // request #.
            }

            if (bIsDirtyNymbox) {
                theNymbox.ReleaseSignatures();
                theNymbox.SignContract(server_->m_nymServer);
                theNymbox.SaveContract();
                theNymbox.SaveNymbox();
            }
        } // If nymbox loaded and verified.
    }

    // For any numbers on the server's internal list but NOT on the client's
    // list, the server removes from
    // the internal list. (Because the client must have seen my acknowledgment
    // and thus removed the number
    // from its own list, so the server doesn't need to display it anymore.)
    //
    // Thus: iterate through the server's list of numbers, and see if each is on
    // the client's list. If not,
    // then remove it from my own (server's) internal list as well.
    //
    OTNumList numlist_to_remove; // a temp variable where we will put the
                                 // numbers "to be removed" (so we can remove
                                 // them all at once, after the loop.)
    const int32_t nAcknowledgedNumCount =
        pNym->GetAcknowledgedNumCount(SERVER_ID);

    if (nAcknowledgedNumCount > 0) {
        for (int32_t i = 0; i < nAcknowledgedNumCount; i++) {
            const int64_t lAcknowledgedNum =
                pNym->GetAcknowledgedNum(SERVER_ID, i); // index

            // For any numbers on the server's internal list but NOT on the
            // client's list (according
            // to the incoming message) the server removes them from its
            // internal list. (If the client
            // is done with them, then so is the server.)
            //
            if (false ==
                theMessage.m_AcknowledgedReplies.Verify(lAcknowledgedNum)) {
                numlist_to_remove.Add(lAcknowledgedNum);
            }
        } // for
        if (numlist_to_remove.Count() > 0) {
            std::set<int64_t> set_server_ack;
            if (numlist_to_remove.Output(set_server_ack)) {
                for (auto& it : set_server_ack) {
                    const int64_t lRequestNum = it;
                    if (pNym->RemoveAcknowledgedNum(
                            server_->m_nymServer, server_->m_strServerID,
                            lRequestNum, false)) // bSave=false
                        bIsDirtyNym = true;
                }
            }
        }
    } // if there are server-side ack numbers that could potentially be removed,
      // if client's message doesn't list them.

    if (bIsDirtyNym) {
        pNym->SaveSignedNymfile(server_->m_nymServer); // we save here.
    }

    // Note: in the ultimate future, we wouldn't even save the Nym down here,
    // but we'll let the entire message process
    // and then save the Nym at the end.
    // Then again -- you'd still want to know if the Nym was locked, at each
    // "save attempt" along the way. Because even
    // though the Nym might not actually save at each of those signposts, it
    // should still CANCEL OUT IF IT WOULD FAIL TRYING.
    // Of course we still only want to save the Nym once, but we still want each
    // step along the way -- each vital step that
    // would normally have saved each time -- to know whether or not it will
    // actually work, and if not, to fail the message
    // AT THAT POINT and not somewhere much later, at the bottom, after all
    // kinds of other processing has been done.
    //
    // Therefore in the new version we will probably still "Save" the Nym at
    // each critical point, but INTERNALLY, it won't
    // actually save until the bottom. BUT, even though it won't actually save,
    // it will still know if the TIMESTAMP IS WITHIN
    // VALID RANGE (each time), and it will still know that it has definitely
    // locked the resource (which happens the first time)
    // and it will still want to set the resource as dirty, internally, even
    // when it doesn't save it right away, because otherwise
    // it wouldn't know to save it later, either.

    msgOut.m_strServerID = server_->m_strServerID;
    msgOut.SetAcknowledgments(*pNym); // Must be called AFTER
                                      // msgOut.m_strServerID is already set.
                                      // (It uses it.)

    if (theMessage.m_strCommand.Compare("getRequest")) // This command is
                                                       // special because it's
                                                       // the only one that
                                                       // doesn't require a
                                                       // request number.
    // All of the other commands, below, will fail above if the proper
    // request number isn't included
    // in the message.  They will already have failed by this point if they
    // didn't verify.
    {
        OTLog::vOutput(0, "\n==> Received a getRequest message. Nym: %s ...\n",
                       strMsgNymID.Get());

        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_get_request);

        UserCmdGetRequest(*pNym, theMessage, msgOut);

        return true;
    }
    else if (theMessage.m_strCommand.Compare("getTransactionNum")) {
        OTLog::vOutput(
            0, "\n==> Received a getTransactionNum message. Nym: %s ...\n",
            strMsgNymID.Get());

        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_get_trans_num);

        UserCmdGetTransactionNum(*pNym, theMessage, msgOut);

        return true;
    }
    else if (theMessage.m_strCommand.Compare("checkUser")) {
        OTLog::vOutput(0, "\n==> Received a checkUser message. Nym: %s ...\n",
                       strMsgNymID.Get());

        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_check_user);

        UserCmdCheckUser(*pNym, theMessage, msgOut);

        return true;
    }
    else if (theMessage.m_strCommand.Compare("sendUserMessage")) {
        OTLog::vOutput(
            0, "\n==> Received a sendUserMessage message. Nym: %s ...\n",
            strMsgNymID.Get());

        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_send_message);

        UserCmdSendUserMessage(*pNym, theMessage, msgOut);

        return true;
    }
    else if (theMessage.m_strCommand.Compare("sendUserInstrument")) {
        OTLog::vOutput(
            0, "\n==> Received a sendUserInstrument message. Nym: %s ...\n",
            strMsgNymID.Get());

        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_send_message);

        UserCmdSendUserInstrument(*pNym, theMessage, msgOut);

        return true;
    }
    else if (theMessage.m_strCommand.Compare("deleteUserAccount")) {
        OTLog::vOutput(
            0, "\n==> Received a deleteUserAccount message. Nym: %s ...\n",
            strMsgNymID.Get());

        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_del_user_acct);

        UserCmdDeleteUser(*pNym, theMessage, msgOut);

        return true;
    }
    else if (theMessage.m_strCommand.Compare("deleteAssetAccount")) {
        OTLog::vOutput(
            0, "\n==> Received a deleteAssetAccount message. Nym: %s ...\n",
            strMsgNymID.Get());

        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_del_asset_acct);

        UserCmdDeleteAssetAcct(*pNym, theMessage, msgOut);

        return true;
    }
    else if (theMessage.m_strCommand.Compare("createAccount")) {
        OTLog::vOutput(0,
                       "\n==> Received a createAccount message. Nym: %s ...\n",
                       strMsgNymID.Get());

        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_create_asset_acct);

        UserCmdCreateAccount(*pNym, theMessage, msgOut);

        return true;
    }
    else if (theMessage.m_strCommand.Compare("issueAssetType")) {
        OTLog::vOutput(
            0, "\n==> Received an issueAssetType message. Nym: %s ...\n",
            strMsgNymID.Get());

        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_issue_asset);

        UserCmdIssueAssetType(*pNym, theMessage, msgOut);

        return true;
    }
    else if (theMessage.m_strCommand.Compare("issueBasket")) {
        OTLog::vOutput(0,
                       "\n==> Received an issueBasket message. Nym: %s ...\n",
                       strMsgNymID.Get());

        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_issue_basket);

        UserCmdIssueBasket(*pNym, theMessage, msgOut);

        return true;
    }
    else if (theMessage.m_strCommand.Compare("notarizeTransactions")) {
        OTLog::vOutput(0, "\n==> Received a notarizeTransactions message.  "
                          "Acct: %s Nym: %s  ...\n",
                       theMessage.m_strAcctID.Get(), strMsgNymID.Get());

        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_notarize_transaction);

        UserCmdNotarizeTransactions(*pNym, theMessage, msgOut);

        return true;
    }
    else if (theMessage.m_strCommand.Compare("getNymbox")) {
        OTLog::vOutput(0, "\n==> Received a getNymbox message. Nym: %s ...\n",
                       strMsgNymID.Get());

        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_get_nymbox);

        UserCmdGetNymbox(*pNym, theMessage, msgOut);

        return true;
    }
    else if (theMessage.m_strCommand.Compare("getBoxReceipt")) {
        OTLog::vOutput(0,
                       "\n==> Received a getBoxReceipt message. Nym: %s ...\n",
                       strMsgNymID.Get());

        bool bRunIt = true;
        if (0 == theMessage.m_lDepth)
            OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_get_nymbox)
        else if (1 == theMessage.m_lDepth)
            OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_get_inbox)
        else if (2 == theMessage.m_lDepth)
            OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_get_outbox)
        else
            bRunIt = false;

        if (bRunIt) UserCmdGetBoxReceipt(*pNym, theMessage, msgOut);

        return true;
    }
    else if (theMessage.m_strCommand.Compare("getInbox")) {
        OTLog::vOutput(
            0, "\n==> Received a getInbox message.  Acct: %s Nym: %s  ...\n",
            theMessage.m_strAcctID.Get(), strMsgNymID.Get());

        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_get_inbox);

        UserCmdGetInbox(*pNym, theMessage, msgOut);

        return true;
    }
    else if (theMessage.m_strCommand.Compare("getOutbox")) {
        OTLog::vOutput(
            0, "\n==> Received a getOutbox message.  Acct: %s Nym: %s  ...\n",
            theMessage.m_strAcctID.Get(), strMsgNymID.Get());

        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_get_outbox);

        UserCmdGetOutbox(*pNym, theMessage, msgOut);

        return true;
    }
    else if (theMessage.m_strCommand.Compare("getAccount")) {
        OTLog::vOutput(
            0, "\n==> Received a getAccount message.  Acct: %s Nym: %s  ...\n",
            theMessage.m_strAcctID.Get(), strMsgNymID.Get());

        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_get_acct);

        UserCmdGetAccount(*pNym, theMessage, msgOut);

        return true;
    }
    else if (theMessage.m_strCommand.Compare("getAccountFiles")) {
        OTLog::vOutput(0, "\n==> Received a getAccountFiles message.  Acct: %s "
                          "Nym: %s  ...\n",
                       theMessage.m_strAcctID.Get(), strMsgNymID.Get());

        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_get_inbox);
        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_get_outbox);
        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_get_acct);

        UserCmdGetAccountFiles(*pNym, theMessage, msgOut);

        return true;
    }
    else if (theMessage.m_strCommand.Compare("processNymbox")) {
        OTLog::vOutput(0,
                       "\n==> Received a processNymbox message. Nym: %s ...\n",
                       strMsgNymID.Get());

        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_process_nymbox);

        UserCmdProcessNymbox(*pNym, theMessage, msgOut);

        return true;
    }
    else if (theMessage.m_strCommand.Compare("processInbox")) {
        OTLog::vOutput(
            0, "\n==> Received a processInbox message. Acct: %s Nym: %s  ...\n",
            theMessage.m_strAcctID.Get(), strMsgNymID.Get());

        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_process_inbox);

        UserCmdProcessInbox(*pNym, theMessage, msgOut);

        return true;
    }
    else if (theMessage.m_strCommand.Compare("queryAssetTypes")) {
        OTLog::vOutput(
            0, "\n==> Received a queryAssetTypes message. Nym: %s ...\n",
            strMsgNymID.Get());

        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_get_contract);

        UserCmdQueryAssetTypes(*pNym, theMessage, msgOut);

        return true;
    }
    else if (theMessage.m_strCommand.Compare("getContract")) {
        OTLog::vOutput(0, "\n==> Received a getContract message. Nym: %s ...\n",
                       strMsgNymID.Get());

        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_get_contract);

        UserCmdGetContract(*pNym, theMessage, msgOut);

        return true;
    }
    else if (theMessage.m_strCommand.Compare("getMint")) {
        OTLog::vOutput(0, "\n==> Received a getMint message. Nym: %s ...\n",
                       strMsgNymID.Get());

        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_get_mint);

        UserCmdGetMint(*pNym, theMessage, msgOut);

        return true;
    }
    else if (theMessage.m_strCommand.Compare("getMarketList")) {
        OTLog::vOutput(0,
                       "\n==> Received a getMarketList message. Nym: %s ...\n",
                       strMsgNymID.Get());

        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_get_market_list);

        UserCmdGetMarketList(*pNym, theMessage, msgOut);

        return true;
    }
    else if (theMessage.m_strCommand.Compare("getMarketOffers")) {
        OTLog::vOutput(
            0, "\n==> Received a getMarketOffers message. Nym: %s ...\n",
            strMsgNymID.Get());

        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_get_market_offers);

        UserCmdGetMarketOffers(*pNym, theMessage, msgOut);

        return true;
    }
    else if (theMessage.m_strCommand.Compare("getMarketRecentTrades")) {
        OTLog::vOutput(
            0, "\n==> Received a getMarketRecentTrades message. Nym: %s ...\n",
            strMsgNymID.Get());

        OT_ENFORCE_PERMISSION_MSG(
            ServerSettings::__cmd_get_market_recent_trades);

        UserCmdGetMarketRecentTrades(*pNym, theMessage, msgOut);

        return true;
    }
    else if (theMessage.m_strCommand.Compare("getNym_MarketOffers")) {
        OTLog::vOutput(
            0, "\n==> Received a getNym_MarketOffers message. Nym: %s ...\n",
            strMsgNymID.Get());

        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_get_nym_market_offers);

        UserCmdGetNym_MarketOffers(*pNym, theMessage, msgOut);

        return true;
    }
    else if (theMessage.m_strCommand.Compare("triggerClause")) {
        OTLog::vOutput(0,
                       "\n==> Received a triggerClause message. Nym: %s ...\n",
                       strMsgNymID.Get());

        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_trigger_clause);

        UserCmdTriggerClause(*pNym, theMessage, msgOut);

        return true;
    }
    else if (theMessage.m_strCommand.Compare("usageCredits")) {
        OTLog::vOutput(0,
                       "\n==> Received a usageCredits message. Nym: %s ...\n",
                       strMsgNymID.Get());

        OT_ENFORCE_PERMISSION_MSG(ServerSettings::__cmd_usage_credits);

        UserCmdUsageCredits(*pNym, theMessage, msgOut);

        return true;
    }
    else {
        OTLog::vError("Unknown command type in the XML, or missing payload, in "
                      "ProcessMessage.\n");

        OTString strTemp;
        strTemp.Format("@%s", theMessage.m_strCommand.Get()); // Todo security.
                                                              // Review this.

        msgOut.m_strCommand = strTemp;
        msgOut.m_strAcctID = theMessage.m_strAcctID;
        msgOut.m_strServerID = theMessage.m_strServerID;
        msgOut.m_strNymID = theMessage.m_strNymID;

        msgOut.m_bSuccess = false;

        OTString strRef(theMessage);

        msgOut.m_ascInReferenceTo.SetString(strRef);

        msgOut.SignContract(server_->m_nymServer);
        msgOut.SaveContract();

        return false;
    }
}

---

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

• /usr/local/src/opentxs/include/opentxs/server/UserCommandProcessor.hpp
• /usr/local/src/opentxs/src/server/UserCommandProcessor.cpp