opentxs::OTServerConnection Class Reference

#include <OTServerConnection.hpp>

Public Member Functions
	OTServerConnection (OTWallet &theWallet, OTClient &theClient)
EXPORT	~OTServerConnection ()
bool	GetServerID (OTIdentifier &theID) const
OTPseudonym *	GetNym () const
OTServerContract *	GetServerContract () const
OTWallet *	GetWallet () const
bool	IsFocused () const
bool	SetFocus (OTPseudonym &theNym, OTServerContract &theServerContract, TransportCallback *pCallback)
EXPORT bool	Connect (const OTPseudonym &, const OTServerContract &, const OTString &, const OTString &, const OTString &) const
void	OnServerResponseToGetRequestNumber (int64_t lNewRequestNumber) const
void	ProcessMessageOut (const char *buf, const int32_t *pnExpectReply)
void	ProcessMessageOut (const OTMessage &theMessage) const
EXPORT bool	ProcessInBuffer (const OTMessage &) const
bool	ProcessReply (u_header &theCMD, OTMessage &theServerReply)
bool	ProcessType1Cmd (u_header &theCMD, OTMessage &theServerReply) const
bool	SignAndSend (OTMessage &theMessage) const

Detailed Description

Definition at line 148 of file OTServerConnection.hpp.

Constructor & Destructor Documentation

opentxs::OTServerConnection::OTServerConnection	(	OTWallet &	theWallet,
		OTClient &	theClient
	)

Definition at line 300 of file OTServerConnection.cpp.

{
    m_pCallback = nullptr;
    m_bFocused = false;
    m_pNym = nullptr;
    m_pServerContract = nullptr;
    m_pWallet = &theWallet;
    m_pClient = &theClient;
}

EXPORT opentxs::OTServerConnection::~OTServerConnection ( )

inline

Definition at line 167 of file OTServerConnection.hpp.

    {
    }

Member Function Documentation

EXPORT bool opentxs::OTServerConnection::Connect ( const OTPseudonym &  , const OTServerContract &  , const OTString &  , const OTString &  , const OTString &    ) const

inline

Definition at line 196 of file OTServerConnection.hpp.

    {
        return false;
    }

OTPseudonym* opentxs::OTServerConnection::GetNym ( ) const

inline

Definition at line 173 of file OTServerConnection.hpp.

    {
        return m_pNym;
    }

OTServerContract* opentxs::OTServerConnection::GetServerContract ( ) const

inline

Definition at line 177 of file OTServerConnection.hpp.

    {
        return m_pServerContract;
    }

bool opentxs::OTServerConnection::GetServerID

(

OTIdentifier &

theID

)

const

Definition at line 283 of file OTServerConnection.cpp.

{
    if (m_pServerContract) {
        m_pServerContract->GetIdentifier(theID);
        return true;
    }
    return false;
}

OTWallet* opentxs::OTServerConnection::GetWallet ( ) const

inline

Definition at line 181 of file OTServerConnection.hpp.

    {
        return m_pWallet;
    }

bool opentxs::OTServerConnection::IsFocused ( ) const

inline

Definition at line 186 of file OTServerConnection.hpp.

    {
        return m_bFocused;
    }

void opentxs::OTServerConnection::OnServerResponseToGetRequestNumber

(

int64_t

lNewRequestNumber

)

const

Definition at line 266 of file OTServerConnection.cpp.

{
    if (m_pNym && m_pServerContract) {
        otOut << "Received new request number from the server: "
              << lNewRequestNumber << ". Updating Nym records...\n";

        OTString strServerID;
        m_pServerContract->GetIdentifier(strServerID);
        m_pNym->OnUpdateRequestNum(*m_pNym, strServerID, lNewRequestNumber);
    }
    else {
        otErr << "Expected m_pNym or m_pServerContract to be not null in "
                 "OTServerConnection::OnServerResponseToGetRequestNumber.\n";
    }
}

EXPORT bool opentxs::OTServerConnection::ProcessInBuffer ( const OTMessage &  ) const

inline

Definition at line 208 of file OTServerConnection.hpp.

    {
        return false;
    }

void opentxs::OTServerConnection::ProcessMessageOut	(	const char *	buf,
		const int32_t *	pnExpectReply
	)

Definition at line 623 of file OTServerConnection.cpp.

{

    OT_ASSERT(nullptr != buf);

    bool bSendCommand = false;
    bool bSendPayload = false;

    OTMessage theMessage;

    bool bHandledIt = false;

    u_header theCMD;

    // clear the header
    memset((void*)theCMD.buf, 0, OT_CMD_HEADER_SIZE);

    // Simple rule here: In each of the below if statements,
    // YOU MUST set up the header bytes HERE!
    // OR you must set the boolean bSendCommand TO TRUE!!
    // It must be one or the other in each block.
    // If you set to true, code at the bottom will calculate header
    // for you. If you fail to do this, the header is now uncalculated either
    // way.
    // Don't send uncalculated headers to the server unless doing it on purpose
    // for TESTING.

    if (buf[0] == '1') {
        bHandledIt = true;

        theCMD.fields.type_id = CMD_TYPE_1;
        theCMD.fields.command_id = TYPE_1_CMD_1;
        theCMD.fields.size = 0;
        theCMD.fields.checksum =
            CalcChecksum(theCMD.buf, OT_CMD_HEADER_SIZE - 1);

        int32_t nChecksum = theCMD.fields.checksum;

        otOut << "(User has instructed to send a size " << OT_CMD_HEADER_SIZE
              << ", TYPE 1 "
                 "COMMAND to the server...)\n CHECKSUM: " << nChecksum << "\n";
        bSendCommand = true;
    }
    else if (buf[0] == '2') {
        bHandledIt = true;

        theCMD.fields.type_id = 12;
        theCMD.fields.command_id = 3;
        theCMD.fields.size = 98;
        theCMD.fields.checksum =
            CalcChecksum(theCMD.buf, OT_CMD_HEADER_SIZE - 1);

        otOut << "(User has instructed to send a size "
              << (OT_CMD_HEADER_SIZE + 3) << ", **malformed "
                                             "command** to the server...)\n";
        bSendCommand = true;
    }
    // Empty OTMessage including signed XML, but no other commands
    else if (buf[0] == '3') {
        otOut << "(User has instructed to create a signed XML message "
                 "and send it to the server...)\n";
        bHandledIt = true;

        // Normally you'd update the member variables here, before signing it.
        // But this is just an empty OTMessage.

        // When a message is signed, it updates its m_xmlUnsigned contents to
        // the values in the members variables
        m_pWallet->SignContractWithFirstNymOnList(theMessage);

        // SaveContract takes m_xmlUnsigned and wraps it with the signatures and
        // ------- BEGIN  bookends
        // If you don't pass a string in, then SaveContract saves the new
        // version to its member, m_strRawFile
        theMessage.SaveContract();

        bSendCommand = true;
        bSendPayload = true;
    }

    // Above are various test messages.

    // This section for commands that involve building full XML messages,
    // that is, most of the real implementation of the transaction protocol.

    // If we can match the user's request to a client command,
    // AND theClient object is able to process that request into
    // a payload, THEN we create the header and send it all down the pipe.

    if (!bHandledIt && m_pNym && m_pServerContract) {
        // check server ID command
        if (buf[0] == 'c') {
            otOut << "(User has instructed to send a checkServerID "
                     "command to the server...)\n";

            // if successful setting up the command payload...

            if (m_pClient->ProcessUserCommand(OTClient::checkServerID,
                                              theMessage, *m_pNym,
                                              *m_pServerContract, nullptr) >
                0) // nullptr pAccount on this command.
            {
                bSendCommand = true;
                bSendPayload = true;
            }
            else
                otErr << "Error processing checkServerID command in "
                         "ProcessMessage: " << buf[0] << "\n";
        }

        // register new user account
        else if (buf[0] == 'r') {
            otOut << "(User has instructed to send a createUserAccount "
                     "command to the server...)\n";

            // if successful setting up the command payload...

            if (m_pClient->ProcessUserCommand(OTClient::createUserAccount,
                                              theMessage, *m_pNym,
                                              *m_pServerContract, nullptr) >
                0) // nullptr pAccount on this command.
            {
                bSendCommand = true;
                bSendPayload = true;
            }
            else
                otErr << "Error processing createUserAccount command in "
                         "ProcessMessage: " << buf[0] << "\n";
        }

        // ALL MESSAGES BELOW THIS POINT SHOULD ATTACH A REQUEST NUMBER IF THEY
        // EXPECT THE SERVER TO PROCESS THEM.
        // (Handled inside ProcessUserCommand)

        // checkUser
        else if (buf[0] == 'u') {
            otOut << "(User has instructed to send a checkUser command "
                     "to the server...)\n";

            // if successful setting up the command payload...

            if (m_pClient->ProcessUserCommand(OTClient::checkUser, theMessage,
                                              *m_pNym, *m_pServerContract,
                                              nullptr)) // nullptr pAccount on
                                                        // this command.
            {
                bSendCommand = true;
                bSendPayload = true;
            }
            else
                otErr << "Error processing checkUser command in "
                         "ProcessMessage: " << buf[0] << "\n";
        }

        // register new asset account
        else if (buf[0] == 'a') {
            otOut << "(User has instructed to send a createAccount "
                     "command to the server...)\n";

            // if successful setting up the command payload...

            if (m_pClient->ProcessUserCommand(
                    OTClient::createAccount, theMessage, *m_pNym,
                    *m_pServerContract,
                    nullptr)) // nullptr pAccount on this command.
            {
                bSendCommand = true;
                bSendPayload = true;
            }
            else
                otErr << "Error processing createAccount command in "
                         "ProcessMessage: " << buf[0] << "\n";
        }

        // issue a new asset type
        else if (!strcmp(buf, "issue\n")) {
            otOut << "(User has instructed to send an issueAssetType "
                     "command to the server...)\n";

            // if successful setting up the command payload...

            if (m_pClient->ProcessUserCommand(OTClient::issueAssetType,
                                              theMessage, *m_pNym,
                                              *m_pServerContract, nullptr) >
                0) // nullptr pAccount on this command.
            {
                bSendCommand = true;
                bSendPayload = true;
            }
            else
                otErr << "Error processing issueAssetType command in "
                         "ProcessMessage: " << buf[0] << "\n";
        }

        // issue a new basket asset type
        else if (!strcmp(buf, "basket\n")) {
            otOut << "(User has instructed to send an issueBasket "
                     "command to the server...)\n";

            // if successful setting up the command payload...

            if (m_pClient->ProcessUserCommand(OTClient::issueBasket, theMessage,
                                              *m_pNym, *m_pServerContract,
                                              nullptr) >
                0) // nullptr pAccount on this command.
            {
                bSendCommand = true;
                bSendPayload = true;
            }
            else
                otErr << "Error processing issueBasket command in "
                         "ProcessMessage: " << buf[0] << "\n";
        }

        // exchange in/out of a basket currency
        else if (!strcmp(buf, "exchange\n")) {
            otOut << "(User has instructed to send an exchangeBasket "
                     "command to the server...)\n";

            // if successful setting up the command payload...

            if (m_pClient->ProcessUserCommand(OTClient::exchangeBasket,
                                              theMessage, *m_pNym,
                                              *m_pServerContract, nullptr) >
                0) // nullptr pAccount on this command.
            {
                bSendCommand = true;
                bSendPayload = true;
            }
            else
                otErr << "Error processing exchangeBasket command in "
                         "ProcessMessage: " << buf[0] << "\n";
        }

        // make an offer and put it onto a market.
        else if (!strcmp(buf, "offer\n")) {
            otOut << "(User has instructed to send a marketOffer "
                     "command to the server...)\n";

            // if successful setting up the command payload...

            if (m_pClient->ProcessUserCommand(OTClient::marketOffer, theMessage,
                                              *m_pNym, *m_pServerContract,
                                              nullptr) >
                0) // nullptr pAccount on this command.
            {
                bSendCommand = true;
                bSendPayload = true;
            }
            else
                otErr << "Error processing marketOffer command in "
                         "ProcessMessage: " << buf[0] << "\n";
        }

        // set asset contract's name
        else if (!strcmp(buf, "setassetname\n")) {
            otOut << "(User has instructed to set an Asset Contract's "
                     "client-side name...)\n";

            // if successful setting up the command payload...

            if (m_pClient->ProcessUserCommand(
                    OTClient::setAssetName, theMessage, *m_pNym,
                    *m_pServerContract,
                    nullptr)) // nullptr pAccount on this command.
            {
                //                bSendCommand = true; // No message sent.
                //                bSendPayload = true;
            }
        }

        // set server contract's name
        else if (!strcmp(buf, "setservername\n")) {
            otOut << "(User has instructed to set a Server Contract's "
                     "client-side name...)\n";

            // if successful setting up the command payload...

            if (m_pClient->ProcessUserCommand(OTClient::setServerName,
                                              theMessage, *m_pNym,
                                              *m_pServerContract, nullptr) >
                0) // nullptr pAccount on this command.
            {
                //                bSendCommand = true; // No message sent.
                //                bSendPayload = true;
            }
        }

        // set nym name
        else if (!strcmp(buf, "setnymname\n")) {
            otOut
                << "(User has instructed to set a Nym's client-side name...)\n";

            // if successful setting up the command payload...

            if (m_pClient->ProcessUserCommand(OTClient::setNymName, theMessage,
                                              *m_pNym, *m_pServerContract,
                                              nullptr) >
                0) // nullptr pAccount on this command.
            {
                //                bSendCommand = true; // No message sent.
                //                bSendPayload = true;
            }
        }

        // set account name
        else if (!strcmp(buf, "setaccountname\n")) {
            otOut << "(User wants to set an Asset Account's client-side "
                     "name...)\n";

            // if successful setting up the command payload...

            if (m_pClient->ProcessUserCommand(OTClient::setAccountName,
                                              theMessage, *m_pNym,
                                              *m_pServerContract, nullptr) >
                0) // nullptr pAccount on this command.
            {
                //                bSendCommand = true; // No message sent.
                //                bSendPayload = true;
            }
        }

        // sendUserMessage
        else if (buf[0] == 's') {
            otOut << "(User has instructed to send a sendUserMessage "
                     "command to the server...)\n";

            // if successful setting up the command payload...

            if (m_pClient->ProcessUserCommand(OTClient::sendUserMessage,
                                              theMessage, *m_pNym,
                                              *m_pServerContract, nullptr) >
                0) // nullptr pAccount on this command.
            {
                bSendCommand = true;
                bSendPayload = true;
            }
            else
                otErr << "Error processing sendUserMessage command in "
                         "ProcessMessage: " << buf[0] << "\n";
        }

        // get nymbox
        else if (buf[0] == 'y') {
            otOut << "(User has instructed to send a getNymbox command "
                     "to the server...)\n";

            // if successful setting up the command payload...

            if (m_pClient->ProcessUserCommand(OTClient::getNymbox, theMessage,
                                              *m_pNym, *m_pServerContract,
                                              nullptr) >
                0) // nullptr pAccount on this command.
            {
                bSendCommand = true;
                bSendPayload = true;
            }
            else
                otErr << "Error processing getNymbox command in "
                         "ProcessMessage: " << buf[0] << "\n";
        }

        // get inbox
        else if (buf[0] == 'i') {
            otOut << "(User has instructed to send a getInbox command "
                     "to the server...)\n";

            // if successful setting up the command payload...

            if (m_pClient->ProcessUserCommand(
                    OTClient::getInbox, theMessage, *m_pNym, *m_pServerContract,
                    nullptr) > 0) // nullptr pAccount on this command.
            {
                bSendCommand = true;
                bSendPayload = true;
            }
            else
                otErr << "Error processing getInbox command in ProcessMessage: "
                      << buf[0] << "\n";
        }

        // get outbox
        else if (buf[0] == 'o') {
            otOut << "(User has instructed to send a getOutbox command "
                     "to the server...)\n";

            // if successful setting up the command payload...

            if (m_pClient->ProcessUserCommand(OTClient::getOutbox, theMessage,
                                              *m_pNym, *m_pServerContract,
                                              nullptr) >
                0) // nullptr pAccount on this command.
            {
                bSendCommand = true;
                bSendPayload = true;
            }
            else
                otErr << "Error processing getOutbox command in "
                         "ProcessMessage: " << buf[0] << "\n";
        }

        // deposit cheque
        else if (buf[0] == 'q') {
            otOut << "User has instructed to deposit a cheque...\n";

            // if successful setting up the command payload...

            if (m_pClient->ProcessUserCommand(OTClient::notarizeCheque,
                                              theMessage, *m_pNym,
                                              *m_pServerContract, nullptr) >
                0) // nullptr pAccount on this command.
            {
                bSendCommand = true;
                bSendPayload = true;
            }
            else
                otErr << "Error processing deposit cheque command in "
                         "ProcessMessage: " << buf[0] << "\n";
        }

        // withdraw voucher
        else if (buf[0] == 'v') {
            otOut << "User has instructed to withdraw a voucher (like "
                     "a cashier's cheque)...\n";

            // if successful setting up the command payload...

            if (m_pClient->ProcessUserCommand(OTClient::withdrawVoucher,
                                              theMessage, *m_pNym,
                                              *m_pServerContract, nullptr) >
                0) // nullptr pAccount on this command.
            {
                bSendCommand = true;
                bSendPayload = true;
            }
            else
                otErr << "Error processing withdraw voucher command in "
                         "ProcessMessage: " << buf[0] << "\n";
        }

        // withdraw cash
        else if (buf[0] == 'w') {
            otOut << "(User has instructed to withdraw cash...)\n";

            // if successful setting up the command payload...

            if (m_pClient->ProcessUserCommand(OTClient::notarizeWithdrawal,
                                              theMessage, *m_pNym,
                                              *m_pServerContract, nullptr) >
                0) // nullptr pAccount on this command.
            {
                bSendCommand = true;
                bSendPayload = true;
            }
            else
                otErr << "Error processing withdraw command in ProcessMessage: "
                      << buf[0] << "\n";
        }

        // deposit tokens
        else if (buf[0] == 'd') {
            otOut << "(User has instructed to deposit cash tokens...)\n";

            // if successful setting up the command payload...

            if (m_pClient->ProcessUserCommand(OTClient::notarizeDeposit,
                                              theMessage, *m_pNym,
                                              *m_pServerContract, nullptr) >
                0) // nullptr pAccount on this command.
            {
                bSendCommand = true;
                bSendPayload = true;
            }
            else
                otErr << "Error processing deposit command in ProcessMessage: "
                      << buf[0] << "\n";
        }

        // activate payment plan
        else if (!strcmp(buf, "plan\n")) {
            otOut << "User has instructed to activate a payment plan...\n";

            // if successful setting up the command payload...

            if (m_pClient->ProcessUserCommand(OTClient::paymentPlan, theMessage,
                                              *m_pNym, *m_pServerContract,
                                              nullptr) >
                0) // nullptr pAccount on this command.
            {
                bSendCommand = true;
                bSendPayload = true;
            }
            else
                otErr << "Error processing payment plan command in "
                         "ProcessMessage: " << buf[0] << "\n";
        }

        // deposit purse
        else if (buf[0] == 'p') {
            otOut << "(User has instructed to deposit a purse "
                     "containing cash...)\n";

            // if successful setting up the command payload...

            if (m_pClient->ProcessUserCommand(OTClient::notarizePurse,
                                              theMessage, *m_pNym,
                                              *m_pServerContract, nullptr) >
                0) // nullptr pAccount on this command.
            {
                bSendCommand = true;
                bSendPayload = true;
            }
            else
                otErr << "Error processing deposit command in ProcessMessage: "
                      << buf[0] << "\n";
        }

        // get account
        else if (!strcmp(buf, "test\n")) {
            otOut << "(User has instructed to perform a test...)\n";

            // if successful setting up the command payload...

            if (m_pNym) {
                OTString strMessage(
                    "Well well well, this is just a little bit of "
                    "plaintext.\nNotice there are NO NEWLINES at the start.\n"
                    "I'm just trying to make it as long as i can, so that\nI "
                    "can test the envelope and armor functionality.\n");

                otOut << "MESSAGE:\n------>" << strMessage << "<--------\n";

                OTASCIIArmor ascMessage(strMessage);

                otOut << "ASCII ARMOR:\n------>" << ascMessage << "<--------\n";

                OTEnvelope theEnvelope;
                theEnvelope.Seal(*m_pNym, strMessage);

                ascMessage.Release();

                theEnvelope.GetAsciiArmoredData(ascMessage);

                otOut << "ENCRYPTED PLAIN TEXT AND THEN ASCII "
                         "ARMOR:\n------>" << ascMessage << "<--------\n";

                strMessage.Release();

                OTEnvelope the2Envelope(ascMessage);
                the2Envelope.Open(*m_pNym, strMessage);

                otOut << "DECRYPTED PLAIN TEXT:\n------>" << strMessage
                      << "<--------\n";

                OTEnvelope the3Envelope;
                the3Envelope.Seal(*m_pNym, strMessage.Get());

                ascMessage.Release();

                the3Envelope.GetAsciiArmoredData(ascMessage);

                otOut << "RE-ENCRYPTED PLAIN TEXT AND THEN ASCII "
                         "ARMOR:\n------>" << ascMessage << "<--------\n";

                strMessage.Release();

                OTEnvelope the4Envelope(ascMessage);
                the4Envelope.Open(*m_pNym, strMessage);

                otOut << "RE-DECRYPTED PLAIN TEXT:\n------>" << strMessage
                      << "<--------\n";

                OTEnvelope the5Envelope;
                the5Envelope.Seal(*m_pNym, strMessage.Get());

                ascMessage.Release();

                the3Envelope.GetAsciiArmoredData(ascMessage);

                otOut << "RE-RE-ENCRYPTED PLAIN TEXT AND THEN ASCII "
                         "ARMOR:\n------>" << ascMessage << "<--------\n";

                strMessage.Release();

                OTEnvelope the6Envelope(ascMessage);
                the6Envelope.Open(*m_pNym, strMessage);

                otOut << "RE-RE-DECRYPTED PLAIN TEXT:\n------>" << strMessage
                      << "<--------\n";
            }

        }

        // get account
        else if (!strcmp(buf, "get\n")) {
            otOut << "(User has instructed to send a getAccount "
                     "command to the server...)\n";

            // if successful setting up the command payload...

            if (m_pClient->ProcessUserCommand(OTClient::getAccount, theMessage,
                                              *m_pNym, *m_pServerContract,
                                              nullptr) >
                0) // nullptr pAccount on this command.
            {
                bSendCommand = true;
                bSendPayload = true;
            }
            else
                otErr << "Error processing getAccount command in "
                         "ProcessMessage: " << buf[0] << "\n";
        }

        // get contract
        else if (!strcmp(buf, "getcontract\n")) {
            otOut << "(User has instructed to send a getContract "
                     "command to the server...)\n";

            // if successful setting up the command payload...

            if (m_pClient->ProcessUserCommand(OTClient::getContract, theMessage,
                                              *m_pNym, *m_pServerContract,
                                              nullptr) >
                0) // nullptr pAccount on this command.
            {
                bSendCommand = true;
                bSendPayload = true;
            }
            else
                otErr << "Error processing getContract command in "
                         "ProcessMessage: " << buf[0] << "\n";
        }

        // sign contract
        else if (!strcmp(buf, "signcontract\n")) {
            otOut << "Is the contract a server contract, or an asset "
                     "contract [s/a]: ";
            OTString strContractType;
            strContractType.OTfgets(std::cin);

            char cContractType = 's';
            bool bIsAssetContract = strContractType.At(0, cContractType);

            if (bIsAssetContract) {
                if ('S' == cContractType || 's' == cContractType)
                    bIsAssetContract = false;
            }
            otOut << "Is the contract properly escaped already? (If "
                     "escaped, all lines beginning with ----- will "
                     "instead appear as - ----- ) [y\n]: ";
            // User input.
            // I need a from account, Yes even in a deposit, it's still the
            // "From" account.
            // The "To" account is only used for a transfer. (And perhaps for a
            // 2-way trade.)
            OTString strEscape;
            strEscape.OTfgets(std::cin);

            char cEscape = 'n';
            bool bEscaped = strEscape.At(0, cEscape);

            if (bEscaped) {
                if ('N' == cEscape || 'n' == cEscape) bEscaped = false;
            }

            otOut << "Please enter an unsigned asset contract; "
                     "terminate with ~ on a new line:\n> ";
            OTString strContract;
            char decode_buffer[200]; // Safe since we only read
                                     // sizeof(decode_buffer)-1

            do {
                decode_buffer[0] = 0; // Make it fresh.

                if ((nullptr !=
                     fgets(decode_buffer, sizeof(decode_buffer) - 1, stdin)) &&
                    (decode_buffer[0] != '~')) {
                    if (!bEscaped && decode_buffer[0] == '-') {
                        strContract.Concatenate("- ");
                    }
                    strContract.Concatenate("%s", decode_buffer);
                    otOut << "> ";
                }
                else {
                    break;
                }

            } while (decode_buffer[0] != '~');

            OTServerContract theServerContract;
            OTAssetContract theAssetContract;

            OTContract* pContract =
                bIsAssetContract
                    ? dynamic_cast<OTContract*>(&theAssetContract)
                    : dynamic_cast<OTContract*>(&theServerContract);

            pContract->CreateContract(strContract, *m_pNym);

            // re-using strContract here for output this time.
            strContract.Release();
            pContract->SaveContractRaw(strContract);

            otOut << ".\n..\n...\n....\n.....\n......\n.......\n........\n....."
                     "....\n\nNEW CONTRACT:\n\n" << strContract << "\n";
        }

        // get mint
        else if (!strcmp(buf, "getmint\n")) {
            otOut << "(User has instructed to send a getMint command "
                     "to the server...)\n";

            // if successful setting up the command payload...

            if (m_pClient->ProcessUserCommand(
                    OTClient::getMint, theMessage, *m_pNym, *m_pServerContract,
                    nullptr) > 0) // nullptr pAccount on this command.
            {
                bSendCommand = true;
                bSendPayload = true;
            }
            else
                otErr << "Error processing getMint command in ProcessMessage: "
                      << buf[0] << "\n";
        }

        // notarize transfer
        else if (buf[0] == 't') {
            otOut << "(User has instructed to send a Transfer command "
                     "(Notarize Transactions) to the server...)\n";

            // if successful setting up the command payload...

            if (m_pClient->ProcessUserCommand(OTClient::notarizeTransfer,
                                              theMessage, *m_pNym,
                                              *m_pServerContract, nullptr) >
                0) // nullptr pAccount on this command.
            {
                bSendCommand = true;
                bSendPayload = true;
            }
            else
                otErr << "Error processing notarizeTransactions command "
                         "in ProcessMessage: " << buf[0] << "\n";
        }

        // getRequest
        else if (buf[0] == 'g') {
            otOut << "(User has instructed to send a getRequest "
                     "command to the server...)\n";

            // if successful setting up the command payload...

            if (m_pClient->ProcessUserCommand(OTClient::getRequest, theMessage,
                                              *m_pNym, *m_pServerContract,
                                              nullptr) >
                0) // nullptr pAccount on this command.
            {
                bSendCommand = true;
                bSendPayload = true;
            }
            else
                otErr << "Error processing getRequest command in "
                         "ProcessMessage: " << buf[0] << "\n";
        }

        // getTransactionNum
        else if (buf[0] == 'n') {
            // I just coded (here) for myself a secret option (for testing)...
            // Optionally instead of JUST 'n', I can put n <number>, (without
            // brackets) and
            // this code will add that number to my list of issued and
            // transaction numbers.
            // I already have the ability to clear the list, so now I can add
            // numbers to it as well.
            // (Which adds to both lists.)
            // I can also remove a number from the transaction list but LEAVE it
            // on the issued list,
            // for example by writing a cheque and throwing it away.
            //
            // This code is for testing and allows me to find and patch any
            // problems without
            // having to re-create my data each time -- speeds up debugging.
            //
            int64_t lTransactionNumber =
                ((strlen(buf) > 2) ? atol(&(buf[2])) : 0);

            if (lTransactionNumber > 0) {
                OTString strServerID;
                m_pServerContract->GetIdentifier(strServerID);

                m_pNym->AddTransactionNum(*m_pNym, strServerID,
                                          lTransactionNumber,
                                          true); // bool bSave=true

                otOut << "Transaction number " << lTransactionNumber
                      << " added to both lists "
                         "(on client side.)\n";
            }
            else {
                otOut << "(User has instructed to send a "
                         "getTransactionNum command to the "
                         "server...)\n";

                // if successful setting up the command payload...

                if (m_pClient->ProcessUserCommand(OTClient::getTransactionNum,
                                                  theMessage, *m_pNym,
                                                  *m_pServerContract, nullptr) >
                    0) // nullptr pAccount on this command.
                {
                    bSendCommand = true;
                    bSendPayload = true;
                }
                else
                    otErr << "Error processing getTransactionNum command "
                             "in ProcessMessage: " << buf[0] << "\n";
            }

        }
        else {
            if (allow_debug) {
                otOut << "\n";
            }
            return;
        }
    }
    else if (!bHandledIt) {
        otOut << "\n";
    }

    if (bSendCommand && bSendPayload) {
        // Voila -- it's sent. (If there was a payload involved.)
        ProcessMessageOut(theMessage);
    } // Otherwise... if it's a "header only" ...
}

void opentxs::OTServerConnection::ProcessMessageOut

(

const OTMessage &

theMessage

)

const

Definition at line 559 of file OTServerConnection.cpp.

{
    u_header theCMD;
    OTPayload thePayload;

    // clear the header
    memset((void*)theCMD.buf, 0, OT_CMD_HEADER_SIZE);

    // Here is where we set up the Payload (so we have the size ready before the
    // header goes out)
    // This is also where we have turned on the encrypted envelopes  }:-)
    OTEnvelope theEnvelope; // All comms should be encrypted in one of these
                            // envelopes.

    // Testing encrypted envelopes...
    const OTPseudonym* pServerNym = nullptr;

    if (m_pServerContract &&
        (nullptr != (pServerNym = m_pServerContract->GetContractPublicNym()))) {
        OTString strEnvelopeContents;
        // Save the ready-to-go message into a string.
        theMessage.SaveContractRaw(strEnvelopeContents);

        // Seal the string up into an encrypted Envelope
        theEnvelope.Seal(*pServerNym, strEnvelopeContents);

        // From here on out, theMessage is disposable. OTPayload takes over.
        // OTMessage doesn't care about checksums and headers.
        thePayload.SetEnvelope(theEnvelope);

        // Now that the payload is ready, we'll set up the header.
        SetupHeader(theCMD, CMD_TYPE_1, TYPE_1_CMD_2, thePayload);
    }
    // else, for whatever reason, we just send an UNencrypted message... (This
    // shouldn't happen anymore...) TODO remove.
    else {
        thePayload.SetMessagePayload(theMessage);

        // Now that the payload is ready, we'll set up the header.
        SetupHeader(theCMD, CMD_TYPE_1, TYPE_1_CMD_1, thePayload);
    }

    OT_ASSERT(IsFocused())
    OT_ASSERT(nullptr != m_pCallback);
    OT_ASSERT(nullptr != m_pServerContract);

    // Call the callback here.
    otOut << "\n=====>BEGIN Sending " << theMessage.m_strCommand
          << " message via ZMQ... Request number: "
          << theMessage.m_strRequestNum << "\n";

    (*m_pCallback)(*m_pServerContract, theEnvelope);

    otWarn << "<=====END Finished sending " << theMessage.m_strCommand
           << " message (and hopefully receiving "
              "a reply.)\nRequest number: " << theMessage.m_strRequestNum
           << "\n\n";

    // At this point, we have sent the envelope to the server.
}

bool opentxs::OTServerConnection::ProcessReply	(	u_header &	theCMD,
		OTMessage &	theServerReply
	)

Definition at line 315 of file OTServerConnection.cpp.

{
    bool bSuccess = false;

    otLog4
        << "\n****************************************************************"
           "\n"
           "===> Processing header from server response.\nFirst 9 bytes are:  "
        << theCMD.buf[0] << " " << theCMD.buf[1] << " " << theCMD.buf[2] << " "
        << theCMD.buf[3] << " " << theCMD.buf[4] << " " << theCMD.buf[5] << " "
        << theCMD.buf[6] << " " << theCMD.buf[7] << " " << theCMD.buf[8]
        << "...\n";

    if (theCMD.fields.type_id == CMD_TYPE_1) {
        otWarn << "Received a Type 1 Command...\n";

        if (IsChecksumValid(theCMD.buf, OT_CMD_HEADER_SIZE)) {
            otWarn << "Checksum is valid! Processing payload.\n";

            if (true == ProcessType1Cmd(theCMD, theServerReply))
                bSuccess = true;
        }
        else {
            otErr << "Invalid checksum - Type 1 Command\n";
        }
    }
    else {
        int32_t nCMDType = theCMD.fields.type_id;
        otErr << "Unknown command type: " << nCMDType << "\n";
    }

    // I added this for error correction. In the event that there are errors,
    // just clean out whatever is in the pipe and throw it away.
    // Should probably send an Error message back, as well.
    if (bSuccess == false) {
        int32_t err = 0, nread = 0;

        for (;;) {
            if (err > 0) // _WIN32
                nread += err;

#ifdef _WIN32
            if (0 == err || SOCKET_ERROR == err) // 0 means disconnect. error
                                                 // means error. >0 means bytes
                                                 // read.
#else
            if (err <= 0)
#endif
                break;
        }

        otErr << "Transmission error--therefore have flushed the pipe, "
                 "discarding " << nread << " bytes.\n";
    }

    return bSuccess;
}

bool opentxs::OTServerConnection::ProcessType1Cmd	(	u_header &	theCMD,
		OTMessage &	theServerReply
	)		const

Definition at line 377 of file OTServerConnection.cpp.

{
    // At this point, the checksum has already validated.
    // Might as well get the PAYLOAD next.
    int32_t err = 0;
    uint32_t nread;

    // Make sure our byte-order is correct here.
    theCMD.fields.size = ntohl(
        theCMD.fields.size); // think this is causing problems... maybe not...

    OTPayload thePayload;
    thePayload.SetPayloadSize(static_cast<uint32_t>(theCMD.fields.size));

    for (nread = 0; nread < theCMD.fields.size; nread += err) {

#ifdef _WIN32
        if (0 == err || SOCKET_ERROR == 0) // 0 means disconnect. error means
                                           // error. otherwise, err contains
                                           // bytes read.
#else
        if (err <= 0)
#endif
            break;
    }

    switch (theCMD.fields.command_id) {
    case TYPE_1_CMD_1:
        otWarn << "Received TYPE 1 CMD 1, an OTMessage.\n";
        break;
    case TYPE_1_CMD_2:
        otLog3 << "Received TYPE 1 CMD 2, an OTEnvelope containing an "
                  "OTMessage.\n";
        break;
    default:
        break;
    }

    if (theCMD.fields.size == 0) {
        otErr << "(The payload was a 0 size.)\n";
        return true;
    }
    else if (nread < theCMD.fields.size) {
        otErr << "Number of bytes read (" << nread
              << ") did NOT match size in header (" << theCMD.fields.size
              << ").\n";
        return false;
    }
    else {
        otLog4 << "Loaded a payload, size: " << theCMD.fields.size << "\n";
    }

    // a signed OTMessage
    if (TYPE_1_CMD_1 == theCMD.fields.command_id) {
        if (thePayload.GetMessagePayload(theServerReply)) {
            otLog4 << "Successfully retrieved payload message...\n";

            if (theServerReply.ParseRawFile()) {
                otLog4 << "Successfully parsed payload message.\n";

                const OTPseudonym* pServerNym =
                    (nullptr != m_pServerContract)
                        ? m_pServerContract->GetContractPublicNym()
                        : nullptr;

                if (m_pServerContract && pServerNym) // todo casting.
                {
                    if (theServerReply.VerifySignature(*pServerNym)) // todo
                                                                     // casting.
                    {
                        otOut << "VERIFIED -- this message was signed "
                                 "by the Server.\n";
                    }
                    else {
                        otOut << "Signature verification failed on "
                                 "this message, proportedly from the "
                                 "Server.\n";
                        return false;
                    }
                }
                else {
                    otOut << "No server contract loaded, or could not "
                             "load public key from server contract.\n";
                    return false;
                }

                return true;
            }
            else {
                otErr << "Error parsing message.\n";
                return false;
            }

        }
        else {
            otErr << "Error retrieving message from payload.\n";
            return false;
        }

    }

    // A base64-encoded envelope, encrypted, and containing a signed message.
    else if (TYPE_1_CMD_2 == theCMD.fields.command_id) {
        OTEnvelope theEnvelope;
        if (thePayload.GetEnvelope(theEnvelope)) {
            otWarn << "===> Received encrypted envelope. (Server "
                      "reply.) Decrypting...\n";

            OTString strEnvelopeContents;

            // Decrypt the Envelope.
            if (m_pNym && theEnvelope.Open(*m_pNym, strEnvelopeContents)) {
                // All decrypted, now let's load the results into an OTMessage.
                // No need to call theMessage.ParseRawFile() after, since
                // LoadContractFromString handles it.
                //
                if (theServerReply.LoadContractFromString(
                        strEnvelopeContents)) {
                    otLog4 << "Success decrypting the message out of "
                              "the envelope and parsing it.\n";

                    const OTPseudonym* pServerNym =
                        (nullptr != m_pServerContract)
                            ? m_pServerContract->GetContractPublicNym()
                            : nullptr;

                    if (m_pServerContract && pServerNym) // todo casting.
                    {
                        if (theServerReply.VerifySignature(
                                *pServerNym)) // todo casting.
                        {
                            otOut << "VERIFIED -- this message was "
                                     "signed by the Server.\n";
                        }
                        else {
                            otOut << "Signature verification failed on "
                                     "this message, purportedly from "
                                     "the Server.\n";
                            return false;
                        }
                    }
                    else {
                        otErr << "No server contract loaded, or could not "
                                 "load public key from server contract.\n";
                        return false;
                    }

                    return true;
                }
                else {
                    otErr << "Error loading message from envelope contents.\n";
                    return false;
                }
            }
            else {
                otErr << "Unable to open envelope.\n";
                return false;
            }
        }
        else {
            otErr << "Error retrieving message from payload.\n";
            return false;
        }
    }
    else {
        otErr << "Error retrieving message from payload. Unknown type.\n";
        return false;
    }
}

bool opentxs::OTServerConnection::SetFocus	(	OTPseudonym &	theNym,
		OTServerContract &	theServerContract,
		TransportCallback *	pCallback
	)

Definition at line 221 of file OTServerConnection.cpp.

{
    if (nullptr == pCallback) {
        otErr << __FUNCTION__ << ": pCallback is nullptr";
        OT_FAIL;
    };

    // We're already connected! You can't use SetFocus if you're in connection
    // mode (TCP instead of HTTP.)
    // if (IsConnected())
    //    return false;
    //
    // This call initializes OpenSSL (only the first time it's called.)
    Initialize();

    // The Client keeps an internal ServerConnection at all times.
    // In SSL/TCP mode, you connect, and stay connected. But in RPC
    // mode, you must call SetFocus before each time you prepare or
    // process any server-related messages. Why? Since the Client normally
    // expects the connection to already be made, and therefore expects
    // to have access to the Nym and Server Contract (and server ID, etc)
    // available since those pointers are normally set during Connect().
    // Since we no longer connect in RPC mode, we must still make sure those
    // pointers are ready by calling SetFocus before they might end up being
    // used.
    // Each time you send a new message, it might be to a different server or
    // from a different nym. That's fine -- just call SetFocus() before you do
    // it.
    m_pNym = &theNym;
    m_pServerContract = &theServerContract;
    m_pCallback = pCallback; // This is what we get instead of a socket, when
                             // we're in RPC mode.
    m_bFocused = true;

    return true;
}

bool opentxs::OTServerConnection::SignAndSend

(

OTMessage &

theMessage

)

const

Definition at line 548 of file OTServerConnection.cpp.

{
    if (m_pNym && m_pWallet && theMessage.SignContract(*m_pNym) &&
        theMessage.SaveContract()) {
        ProcessMessageOut(theMessage);
        return true;
    }

    return false;
}

---

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

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